finalytics 0.4.0__tar.gz → 0.4.2__tar.gz

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

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

{finalytics-0.4.0 → finalytics-0.4.2}/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.2", features = ["kaleido"]}
 ```
 
 Or run the following command:
@@ -41,7 +41,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     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)
@@ -73,7 +73,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     let ticker_symbols = Vec::from(["NVDA", "BRK-A", "AAPL", "ZN=F"]);
     let portfolio = PortfolioBuilder::new().ticker_symbols(ticker_symbols)
                                             .benchmark_symbol("^GSPC")
-                                            .start_date("2017-01-01")
+                                            .start_date("2020-01-01")
                                             .end_date("2023-01-01")
                                             .interval(Interval::OneDay)
                                             .confidence_level(0.95)
@@ -133,7 +133,7 @@ from finalytics import Ticker
 
 ticker = Ticker(symbol="AAPL",
                 start="2023-01-01",
-                end="2023-10-31",
+                end="2023-12-31",
                 interval="1d",
                 confidence_level=0.95,
                 risk_free_rate=0.02)
@@ -148,7 +148,7 @@ ticker.performance_chart().show()
 from finalytics import Portfolio
 
 portfolio = Portfolio(ticker_symbols=["AAPL", "GOOG", "MSFT", "BTC-USD"], 
-                      benchmark_symbol="^GSPC", start_date="2020-01-01", end_date="2022-01-01", interval="1d", 
+                      benchmark_symbol="^GSPC", start_date="2020-01-01", end_date="2023-01-01", interval="1d", 
                       confidence_level=0.95, risk_free_rate=0.02, max_iterations=1000, 
                       objective_function="max_sharpe")
 

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

@@ -1,6 +1,6 @@
 [package]
 name = "finalytics"
-version = "0.5.0"
+version = "0.5.2"
 authors = ["Nnamdi Olisaeloka <nnamdiolisaeloka@gmail.com>"]
 edition = "2021"
 homepage = "https://finalytics.rs/"
@@ -24,18 +24,19 @@ 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.41.3", 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"
 optimization = "0.2.0"
 html-escape = "0.2.13"
-plotly = { version = "0.8.4", package = "plotly-fork"}
+plotly = { version = "0.9.0", features = ["kaleido"] }
 once_cell = "1.19.0"
+futures = "0.3.30"
 
 [features]
 kaleido = ["plotly/kaleido"]

{finalytics-0.4.0 → finalytics-0.4.2}/finalytics/src/analytics/fundamentals.rs

@@ -21,40 +21,41 @@ impl Financials for Ticker {
         let income_statement = self.get_fundamentals("income-statement", "quarterly").await?;
         let balance_sheet = self.get_fundamentals("balance-sheet", "quarterly").await?;
         let cash_flow = self.get_fundamentals("cash-flow", "quarterly").await?;
+        let ratios = vec![
+            Series::new("date", income_statement.column("asOfDate")?),
+            Series::new("Gross Profit Margin", (income_statement.column("GrossProfit")? / income_statement.column("TotalRevenue")?)?),
+            Series::new("Operating Profit Margin", (income_statement.column("EBIT")? / income_statement.column("TotalRevenue")?)?),
+            Series::new("Net Profit Margin", (income_statement.column("NetIncome")? / income_statement.column("TotalRevenue")?)?),
+            Series::new("Return on Assets", (income_statement.column("NetIncome")? / balance_sheet.column("TotalAssets")?)?),
+            Series::new("Return on Equity", (income_statement.column("NetIncome")? / balance_sheet.column("TotalEquityGrossMinorityInterest")?)?),
+            Series::new("Quick Ratio", (balance_sheet.column("CurrentAssets")? / balance_sheet.column("CurrentLiabilities")?)?),
+            Series::new("Current Ratio", (balance_sheet.column("CurrentAssets")? / balance_sheet.column("CurrentLiabilities")?)?),
+            Series::new("Debt to Equity", (balance_sheet.column("TotalLiabilitiesNetMinorityInterest")? / balance_sheet.column("TotalEquityGrossMinorityInterest")?)?),
+            Series::new("Debt to Assets", (balance_sheet.column("TotalLiabilitiesNetMinorityInterest")? / balance_sheet.column("TotalAssets")?)?),
+            Series::new("Interest Coverage", (income_statement.column("EBIT")? / income_statement.column("InterestExpense")?)?),
+            Series::new("Asset Turnover", (income_statement.column("TotalRevenue")? / balance_sheet.column("TotalAssets")?)?),
+            Series::new("Inventory Turnover", (income_statement.column("CostOfRevenue")? / balance_sheet.column("Inventory")?)?),
+            Series::new("Days Receivable", (balance_sheet.column("AccountsReceivable")? / income_statement.column("TotalRevenue")?)? * 365.0),
+            Series::new("Days Inventory", (balance_sheet.column("Inventory")? / income_statement.column("CostOfRevenue")?)? * 365.0),
+            Series::new("Days Payable", (balance_sheet.column("AccountsPayable")? / income_statement.column("CostOfRevenue")?)? * 365.0),
+            Series::new("Earnings per Share", income_statement.column("DilutedEPS")?),
+            Series::new("Price to Earnings", (balance_sheet.column("TotalCapitalization")? / income_statement.column("NetIncome")?)?),
+            Series::new("Price to Book", (balance_sheet.column("TotalCapitalization")? / balance_sheet.column("TotalEquityGrossMinorityInterest")?)?),
+            Series::new("Price to Sales", (balance_sheet.column("TotalCapitalization")? / income_statement.column("TotalRevenue")?)?),
+            Series::new("Price to Cashflow", (balance_sheet.column("TotalCapitalization")? / cash_flow.column("OperatingCashFlow")?)?),
+            Series::new("Price to Free Cashflow", (balance_sheet.column("TotalCapitalization")? / cash_flow.column("FreeCashFlow")?)?),
+        ];
         
-        let df = df!(
-            "date" => *&income_statement.column("asOfDate")?,
-            "Gross Profit Margin" => *&income_statement.column("GrossProfit")? / *&income_statement.column("TotalRevenue")?,
-            "Operating Profit Margin" => *&income_statement.column("EBIT")? / *&income_statement.column("TotalRevenue")?,
-            "Net Profit Margin" => *&income_statement.column("NetIncome")? / *&income_statement.column("TotalRevenue")?,
-            "Return on Assets" => *&income_statement.column("NetIncome")? / *&balance_sheet.column("TotalAssets")?,
-            "Return on Equity" => *&income_statement.column("NetIncome")? / *&balance_sheet.column("TotalEquityGrossMinorityInterest")?,
-            "Quick Ratio" => *&balance_sheet.column("CurrentAssets")? / *&balance_sheet.column("CurrentLiabilities")?,
-            "Current Ratio" => *&balance_sheet.column("CurrentAssets")? / *&balance_sheet.column("CurrentLiabilities")?,
-            "Debt to Equity" => *&balance_sheet.column("TotalLiabilitiesNetMinorityInterest")? / *&balance_sheet.column("TotalEquityGrossMinorityInterest")?,
-            "Debt to Assets" => *&balance_sheet.column("TotalLiabilitiesNetMinorityInterest")? / *&balance_sheet.column("TotalAssets")?,
-            "Interest Coverage" => *&income_statement.column("EBIT")? / *&income_statement.column("InterestExpense")?,
-            "Asset Turnover" => *&income_statement.column("TotalRevenue")? / *&balance_sheet.column("TotalAssets")?,
-            "Inventory Turnover" => *&income_statement.column("CostOfRevenue")? / *&balance_sheet.column("Inventory")?,
-            "Days Receivable" => *&balance_sheet.column("AccountsReceivable")? / *&income_statement.column("TotalRevenue")? * 365.0,
-            "Days Inventory" => *&balance_sheet.column("Inventory")? / *&income_statement.column("CostOfRevenue")? * 365.0,
-            "Days Payable" => *&balance_sheet.column("AccountsPayable")? / *&income_statement.column("CostOfRevenue")? * 365.0,
-            "Earnings per Share" => *&income_statement.column("DilutedEPS")?,
-            "Price to Earnings" => *&balance_sheet.column("TotalCapitalization")? / *&income_statement.column("NetIncome")?,
-            "Price to Book" => *&balance_sheet.column("TotalCapitalization")? / *&balance_sheet.column("TotalEquityGrossMinorityInterest")?,
-            "Price to Sales" => *&balance_sheet.column("TotalCapitalization")? / *&income_statement.column("TotalRevenue")?,
-            "Price to Cashflow" => *&balance_sheet.column("TotalCapitalization")? / *&cash_flow.column("OperatingCashFlow")?,
-            "Price to Free Cashflow" => *&balance_sheet.column("TotalCapitalization")? / *&cash_flow.column("FreeCashFlow")?,
-        )?;
+        let df = DataFrame::new(ratios)?;
 
         // Transpose the DataFrame
-        let dates = df.column("date")?.utf8()?.into_iter()
-            .map(|x| x.unwrap()).collect::<Vec<&str>>();
-        let df = df.drop("date").unwrap();
+        let dates = df.column("date")?.str()?.into_no_null_iter()
+            .collect::<Vec<&str>>();
+        let mut df = df.drop("date").unwrap();
         let items = Series::new("Items", df.get_column_names());
         let mut transposed_df = df.transpose(None, None)?;
         let _ =  transposed_df.set_column_names(&dates)?;
-        let _ = transposed_df.insert_at_idx(0, items)?;
+        let _ = transposed_df.insert_column(0, items)?;
         Ok(transposed_df)
     }
 
@@ -102,15 +103,15 @@ impl Financials for Ticker {
             .collect();
 
         // Select and alias columns using the expressions
-        let renamed_df = df.lazy().select(expressions).collect()?;
+        let mut renamed_df = df.lazy().select(expressions).collect()?;
 
         // Transpose the DataFrame
-        let dates = income_statement.column("asOfDate")?.utf8()?.into_iter()
-            .map(|x| x.unwrap()).collect::<Vec<&str>>();
+        let dates = income_statement.column("asOfDate")?.str()?.into_no_null_iter()
+            .collect::<Vec<&str>>();
         let items = Series::new("Items", renamed_df.get_column_names());
         let mut transposed_df = renamed_df.transpose(None, None)?;
         let _ =  transposed_df.set_column_names(&dates)?;
-        let _ = transposed_df.insert_at_idx(0, items)?;
+        let _ = transposed_df.insert_column(0, items)?;
         Ok(transposed_df)
     }
 
@@ -161,7 +162,7 @@ impl Financials for Ticker {
             "CommonStock", "RetainedEarnings", "CommonStockEquity", "TotalEquityGrossMinorityInterest",
         ];
 
-        // remove item from cols if it doesnt exist in the balance sheet dataframe
+        // remove item from cols if it doesn't exist in the balance sheet dataframe
         cols.retain(|x| balance_sheet.column(*x).is_ok());
 
 
@@ -177,15 +178,15 @@ impl Financials for Ticker {
             .collect();
 
         // Select and alias columns using the expressions
-        let renamed_df = df.lazy().select(expressions).collect()?;
+        let mut renamed_df = df.lazy().select(expressions).collect()?;
 
         // Transpose the DataFrame
-        let dates = balance_sheet.column("asOfDate")?.utf8()?.into_iter()
-            .map(|x| x.unwrap()).collect::<Vec<&str>>();
+        let dates = balance_sheet.column("asOfDate")?.str()?.into_no_null_iter()
+            .collect::<Vec<&str>>();
         let items = Series::new("Items", renamed_df.get_column_names());
         let mut transposed_df = renamed_df.transpose(None, None)?;
         let _ =  transposed_df.set_column_names(&dates)?;
-        let _ = transposed_df.insert_at_idx(0, items)?;
+        let _ = transposed_df.insert_column(0, items)?;
 
         Ok(transposed_df)
 
@@ -267,15 +268,15 @@ impl Financials for Ticker {
             .collect();
 
         // Select and alias columns using the expressions
-        let renamed_df = df.lazy().select(expressions).collect()?;
+        let mut renamed_df = df.lazy().select(expressions).collect()?;
 
         // Transpose the DataFrame
-        let dates = cash_flow.column("asOfDate")?.utf8()?.into_iter()
-            .map(|x| x.unwrap()).collect::<Vec<&str>>();
+        let dates = cash_flow.column("asOfDate")?.str()?.into_no_null_iter()
+            .collect::<Vec<&str>>();
         let items = Series::new("Items", renamed_df.get_column_names());
         let mut transposed_df = renamed_df.transpose(None, None)?;
         let _ =  transposed_df.set_column_names(&dates)?;
-        let _ = transposed_df.insert_at_idx(0, items)?;
+        let _ = transposed_df.insert_column(0, items)?;
 
         Ok(transposed_df)
     }

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

@@ -1,5 +1,7 @@
 use polars::prelude::*;
 use std::error::Error;
+use chrono::{DateTime, NaiveDateTime};
+use futures::future::join_all;
 
 use crate::data::config::Interval;
 use crate::models::ticker::{Ticker, TickerBuilder};
@@ -14,6 +16,7 @@ pub struct TickerPerformanceStats {
     pub benchmark_symbol: String,
     pub start_date: String,
     pub end_date: String,
+    pub dates_array: Vec<String>,
     pub interval: Interval,
     pub confidence_level: f64,
     pub risk_free_rate: f64,
@@ -48,17 +51,22 @@ impl TickerPerformance for Ticker {
             .risk_free_rate(self.risk_free_rate)
             .build();
         let benchmark_returns = benchmark_ticker.roc(1).await?;
-        let benchmark_returns = benchmark_returns.join(
-            &security_returns,
+        let benchmark_returns = security_returns.join(
+            &benchmark_returns,
             &["timestamp"],
             &["timestamp"],
-            JoinArgs::new(JoinType::Inner),
+            JoinArgs::new(JoinType::Left),
         )?;
-        let benchmark_returns = benchmark_returns.sort(&["timestamp"], false, false)?;
+        let benchmark_returns = benchmark_returns.sort(&["timestamp"], SortMultipleOptions::new().with_order_descending(false))?;
         let benchmark_returns = benchmark_returns.fill_null(FillNullStrategy::Forward(None))?;
         let benchmark_returns = benchmark_returns.fill_null(FillNullStrategy::Backward(None))?;
+        let dates_array = benchmark_returns.column("timestamp")?.datetime()?
+            .into_no_null_iter().map(|x| DateTime::from_timestamp_millis(x).unwrap()
+            .naive_local()).collect::<Vec<NaiveDateTime>>();
+        let dates_array = dates_array.iter().map(|x| x.to_string()).collect::<Vec<String>>();
+        let security_returns = benchmark_returns.column(&*self.ticker)?.clone();
         let benchmark_returns = benchmark_returns.column("roc-1")?.clone();
-        let security_returns = security_returns.column(&*self.ticker)?.clone();
+
         let performance_stats = PerformanceStats::compute_stats(
             security_returns.clone(), benchmark_returns.clone(),
             self.risk_free_rate, self.confidence_level, self.interval)?;
@@ -67,6 +75,7 @@ impl TickerPerformance for Ticker {
             benchmark_symbol: self.benchmark_symbol.clone(),
             start_date: self.start_date.clone(),
             end_date: self.end_date.clone(),
+            dates_array,
             interval: self.interval.clone(),
             confidence_level: self.confidence_level,
             risk_free_rate: self.risk_free_rate,
@@ -88,6 +97,7 @@ pub struct PortfolioPerformanceStats {
     pub start_date: String,
     pub end_date: String,
     pub interval: Interval,
+    pub dates_array: Vec<String>,
     pub confidence_level: f64,
     pub risk_free_rate: f64,
     pub portfolio_returns: DataFrame,
@@ -131,21 +141,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();
@@ -156,10 +200,11 @@ impl PortfolioPerformanceStats {
                     df,
                     &["timestamp"],
                     &["timestamp"],
-                    JoinArgs::new(JoinType::Outer),
+                    JoinArgs::new(JoinType::Full).with_coalesce(JoinCoalesce::CoalesceColumns),
                 )?;
         }
-        portfolio_returns = portfolio_returns.sort(&["timestamp"], false, false)?;
+
+        portfolio_returns = portfolio_returns.sort(&["timestamp"], SortMultipleOptions::new().with_order_descending(false))?;
         portfolio_returns = portfolio_returns.fill_null(FillNullStrategy::Forward(None))?;
         portfolio_returns = portfolio_returns.fill_null(FillNullStrategy::Backward(None))?;
 
@@ -171,33 +216,31 @@ impl PortfolioPerformanceStats {
             .risk_free_rate(risk_free_rate)
             .build();
         let benchmark_returns = benchmark_ticker.roc(1).await?;
-        let benchmark_returns = if portfolio_returns.height() > benchmark_returns.height() {
-            benchmark_returns.join(
-            &portfolio_returns,
-            &["timestamp"],
-            &["timestamp"],
-            JoinArgs::new(JoinType::Outer),
-        )?} else {
-            portfolio_returns.join(
+        let benchmark_returns =  portfolio_returns.join(
             &benchmark_returns,
             &["timestamp"],
             &["timestamp"],
-            JoinArgs::new(JoinType::Inner),
-        )?};
+            JoinArgs::new(JoinType::Left),
+        )?;
 
-        let benchmark_returns = benchmark_returns.sort(&["timestamp"], false, false)?;
+        let benchmark_returns = benchmark_returns.sort(&["timestamp"], SortMultipleOptions::new().with_order_descending(false))?;
         let benchmark_returns = benchmark_returns.fill_null(FillNullStrategy::Forward(None))?;
         let benchmark_returns = benchmark_returns.fill_null(FillNullStrategy::Backward(None))?;
+        let dates_array = benchmark_returns.column("timestamp")?.datetime()?
+            .into_no_null_iter().map(|x| DateTime::from_timestamp_millis(x).unwrap()
+            .naive_local()).collect::<Vec<NaiveDateTime>>();
+        let dates_array = dates_array.iter().map(|x| x.to_string()).collect::<Vec<String>>();
         let benchmark_returns = benchmark_returns.column("roc-1")?.clone();
 
         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(),
             interval,
+            dates_array,
             confidence_level,
             risk_free_rate,
             portfolio_returns: portfolio_returns.clone(),
@@ -218,8 +261,16 @@ impl PortfolioPerformanceStats {
     ///
     /// * `PortfolioPerformanceStats` struct
     pub fn compute_stats(&self) -> Result<PortfolioPerformanceStats, Box<dyn Error>> {
-        let mean_returns = self.portfolio_returns.mean().iter().map(|x| x.f64().unwrap()
-            .get(0).unwrap()).collect::<Vec<f64>>();
+        let mean_returns = self.portfolio_returns
+            .get_columns()
+            .iter()
+            .map(|col| {
+                col.f64()
+                    .unwrap()
+                    .mean()
+                    .unwrap()
+            })
+            .collect::<Vec<f64>>();
         let cov_matrix = covariance_matrix(&self.portfolio_returns)?;
 
         let opt_result = portfolio_optimization(&mean_returns, &cov_matrix, &self.portfolio_returns, self.risk_free_rate,
@@ -238,6 +289,7 @@ impl PortfolioPerformanceStats {
             start_date: self.start_date.clone(),
             end_date: self.end_date.clone(),
             interval: self.interval.clone(),
+            dates_array: self.dates_array.clone(),
             confidence_level: self.confidence_level,
             risk_free_rate: self.risk_free_rate,
             portfolio_returns: self.portfolio_returns.clone(),

{finalytics-0.4.0 → finalytics-0.4.2}/finalytics/src/analytics/statistics.rs

@@ -85,7 +85,7 @@ impl PerformanceStats {
         let downside_mask = &returns.lt_eq(0.0).unwrap();
         let downside_returns = returns.filter(downside_mask).unwrap();
         let sortino_ratio = (annualized_return - risk_free_rate) / (std_dev( &downside_returns) * 252.0_f64.sqrt());
-        let excess_returns = returns.clone() - benchmark_returns.clone();
+        let excess_returns = (returns.clone() - benchmark_returns.clone())?;
         let active_return = excess_returns.mean().ok_or("Error calculating active return")?;
         let active_return = ((1.0 + active_return/100.0).powf(252.0) - 1.0) * 100.0;
         let active_risk = std_dev(&excess_returns) * 252.0_f64.sqrt();
@@ -309,7 +309,7 @@ pub fn rand_weights(num_assets: usize) -> Vec<f64> {
 pub fn mean_portfolio_return(weights: &Vec<f64>, mean_returns: &Vec<f64>) -> f64 {
     let weights = Series::new("Weights", weights);
     let mean_returns = Series::new("Mean Returns", mean_returns);
-    let weighted_returns = mean_returns.mul(weights);
+    let weighted_returns = mean_returns.mul(weights).unwrap();
     let mean_portfolio_return = weighted_returns.sum().unwrap();
     mean_portfolio_return
 }
@@ -348,7 +348,7 @@ pub fn daily_portfolio_returns(weights: &Vec<f64>, returns: &DataFrame) -> Serie
         let col_str = returns.get_column_names()[i];
         let security_returns = returns.column(col_str).unwrap().f64().unwrap().to_vec();
         let weighted_returns = security_returns.iter().map(|x| x.unwrap() * weight).collect::<Vec<f64>>();
-        portfolio_returns = portfolio_returns + Series::new("Portfolio Returns", weighted_returns);
+        portfolio_returns = (portfolio_returns + Series::new("Portfolio Returns", weighted_returns)).unwrap();
     }
     portfolio_returns
 }

{finalytics-0.4.0 → finalytics-0.4.2}/finalytics/src/analytics/stochastics.rs

@@ -253,7 +253,7 @@ impl VolatilitySurface for Ticker {
                 let vol_df = df.filter(&mask)?;
                 if vol_df.height() > 0 {
                     let option_price = vol_df.column("lastPrice")?.f64()?.get(0).unwrap();
-                    let option_type = vol_df.column("type")?.utf8()?.get(0).unwrap();
+                    let option_type = vol_df.column("type")?.str()?.get(0).unwrap();
                     let option_type = match option_type {
                         "call" => OptionType::Call,
                         "put" => OptionType::Put,

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

@@ -3,8 +3,8 @@ use plotly::{Bar, Histogram, Layout, Plot, Scatter, Table};
 use plotly::color::NamedColor;
 use plotly::common::{Fill, Marker, MarkerSymbol, Mode, Title};
 use plotly::layout::{Axis, GridPattern, LayoutGrid, RowOrder};
+use plotly::traces::table::{Cells, Header};
 use crate::analytics::statistics::cumulative_returns_list;
-use crate::utils::date_utils::generate_dates;
 use crate::models::portfolio::Portfolio;
 
 
@@ -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();
@@ -111,8 +120,7 @@ impl PortfolioCharts for Portfolio {
     ///
     /// * `Plot` Plotly Chart struct
     fn performance_chart(&self, height: usize, width: usize) -> Result<Plot, Box<dyn Error>> {
-        let dates = generate_dates(&*self.performance_stats.start_date,
-                                   &*self.performance_stats.end_date, 1);
+        let dates = self.performance_stats.dates_array.clone();
 
         let returns = self.performance_stats.optimal_portfolio_returns.f64().unwrap().to_vec()
             .iter().map(|x| x.unwrap()).collect::<Vec<f64>>();
@@ -198,17 +206,24 @@ impl PortfolioCharts for Portfolio {
     fn asset_returns_chart(&self, height: usize, width: usize) -> Result<Plot, Box<dyn Error>> {
         let symbols = self.performance_stats.ticker_symbols.clone();
         let asset_returns = self.performance_stats.portfolio_returns.clone();
-        let dates = generate_dates(&*self.performance_stats.start_date, &*self.performance_stats.end_date, 1);
+        let dates = self.performance_stats.dates_array.clone();
         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()
@@ -273,11 +288,11 @@ impl PortfolioCharts for Portfolio {
 
 
         let trace = Table::new(
-            vec![
+            Header::new(vec![
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Performance Stats"),
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Values"),
-            ],
-            vec![fields, values],
+            ]),
+            Cells::new(vec![fields, values]),
         );
         let mut plot = Plot::new();
         plot.add_trace(trace);

{finalytics-0.4.0 → finalytics-0.4.2}/finalytics/src/charts/ticker.rs

@@ -6,6 +6,7 @@ use num_format::{Locale, ToFormattedString};
 use plotly::common::{Fill, Line, LineShape, Mode, Title};
 use plotly::{Bar, Candlestick, Histogram, Layout, Plot, Scatter, Surface, Table};
 use plotly::layout::{Axis, GridPattern, LayoutGrid, LayoutScene, RangeSelector, RangeSlider, RowOrder, SelectorButton, SelectorStep, StepMode};
+use plotly::traces::table::{Cells, Header};
 
 use crate::models::ticker::Ticker;
 use crate::data::ticker::TickerData;
@@ -13,7 +14,7 @@ use crate::prelude::TechnicalIndicators;
 use crate::analytics::fundamentals::Financials;
 use crate::analytics::performance::TickerPerformance;
 use crate::analytics::stochastics::VolatilitySurface;
-use crate::utils::date_utils::{generate_dates, to_date};
+use crate::utils::date_utils::to_date;
 use crate::analytics::statistics::cumulative_returns_list;
 
 pub trait TickerCharts {
@@ -86,8 +87,7 @@ impl TickerCharts for Ticker {
         let layout = Layout::new()
             .height(height)
             .width(width)
-            .title(Title::new(&*format!("<span style=\"font-weight:bold; color:darkgreen;\">{} Candlestick Chart</span>",
-                                        self.ticker)))
+            .title(&*format!("<span style=\"font-weight:bold; color:darkgreen;\">{} Candlestick Chart</span>", self.ticker))
             .grid(
                 LayoutGrid::new()
                     .rows(3)
@@ -171,9 +171,7 @@ impl TickerCharts for Ticker {
     /// * `Plot` Plotly Chart struct
     async fn performance_chart(&self, height: usize, width: usize) -> Result<Plot, Box<dyn Error>> {
         let performance_stats = self.performance_stats().await?;
-        let dates = generate_dates(&*performance_stats.start_date,
-                                   &*performance_stats.end_date, 1);
-
+        let dates = performance_stats.dates_array;
         let returns = performance_stats.security_returns.f64().unwrap().to_vec()
             .iter().map(|x| x.unwrap()).collect::<Vec<f64>>();
 
@@ -331,11 +329,11 @@ impl TickerCharts for Ticker {
         ];
 
         let trace = Table::new(
-            vec![
+            Header::new(vec![
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Summary Stats"),
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Values"),
-            ],
-            vec![fields, values],
+            ]),
+            Cells::new(vec![fields, values]),
         );
         let mut plot = Plot::new();
         plot.add_trace(trace);
@@ -404,11 +402,11 @@ impl TickerCharts for Ticker {
 
 
         let trace = Table::new(
-            vec![
+            Header::new(vec![
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Performance Stats"),
                 format!("<span style=\"font-weight:bold; color:darkgreen;\">{}</span>", "Values"),
-            ],
-            vec![fields, values],
+            ]),
+            Cells::new(vec![fields, values]),
         );
         let mut plot = Plot::new();
         plot.add_trace(trace);
@@ -453,7 +451,7 @@ impl TickerCharts for Ticker {
                     x.iter()
                         .map(|y| match y {
                             AnyValue::Null => "".to_string(),
-                            AnyValue::Utf8(str_val) => str_val.to_string(),
+                            AnyValue::String(str_val) => str_val.to_string(),
                             AnyValue::Float64(val) => if name == &"Financial Ratios" {format!("{:.2}", val)}
                             else if val > -999.0 && val < 999.0 {format!("${:.2}", val)}
                             else{format!("${}", (val as i64).to_formatted_string(&Locale::en))
@@ -464,8 +462,8 @@ impl TickerCharts for Ticker {
                 })
                 .collect::<Vec<Vec<String>>>();
             let trace = Table::new(
-                fields,
-                values,
+                Header::new(fields),
+                Cells::new(values),
             );
             let mut plot = Plot::new();
             plot.add_trace(trace);