finalytics 0.4.1__tar.gz → 0.4.2__tar.gz

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

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

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

@@ -14,7 +14,7 @@ Add the following to your `Cargo.toml` file:
 
 ```toml
 [dependencies]
-finalytics = {version = "0.5.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.1 → finalytics-0.4.2}/finalytics/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "finalytics"
-version = "0.5.1"
+version = "0.5.2"
 authors = ["Nnamdi Olisaeloka <nnamdiolisaeloka@gmail.com>"]
 edition = "2021"
 homepage = "https://finalytics.rs/"
@@ -24,7 +24,7 @@ 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", "fmt_no_tty"] }
+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"
@@ -34,7 +34,7 @@ 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"
 

{finalytics-0.4.1 → 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.1 → finalytics-0.4.2}/finalytics/src/analytics/performance.rs

@@ -1,5 +1,6 @@
 use polars::prelude::*;
 use std::error::Error;
+use chrono::{DateTime, NaiveDateTime};
 use futures::future::join_all;
 
 use crate::data::config::Interval;
@@ -15,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,
@@ -49,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)?;
@@ -68,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,
@@ -89,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,
@@ -191,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))?;
 
@@ -206,23 +216,20 @@ 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")?;
@@ -233,6 +240,7 @@ impl PortfolioPerformanceStats {
             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(),
@@ -253,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,
@@ -273,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.1 → 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.1 → 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.1 → 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;
 
 
@@ -120,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>>();
@@ -207,7 +206,7 @@ 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 {
@@ -289,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.1 → 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);

{finalytics-0.4.1 → finalytics-0.4.2}/finalytics/src/utils/date_utils.rs

@@ -1,6 +1,5 @@
 use chrono::{DateTime, NaiveDate, NaiveDateTime, Timelike, Utc};
 use std::error::Error;
-use std::str::FromStr;
 
 /// Converts a date string in YYYY-MM-DD format to a Unix Timestamp
 pub fn to_timestamp(date_str: &str) -> Result<i64, Box<dyn Error>> {
@@ -23,22 +22,6 @@ pub fn to_datetime(date_str: &str) -> Result<NaiveDateTime, Box<dyn Error>> {
     Ok(datetime)
 }
 
-/// Generates a vector of dates between a start date and an end date
-pub fn generate_dates(start_date: &str, end_date: &str, interval_days: i64) -> Vec<String> {
-    let start_date = NaiveDate::from_str(start_date).expect("Invalid start date");
-    let end_date = NaiveDate::from_str(end_date).expect("Invalid end date");
-
-    let mut current_date = start_date;
-    let mut date_vector = Vec::new();
-
-    while current_date <= end_date {
-        date_vector.push(current_date.to_string());
-        current_date += chrono::Duration::days(interval_days);
-    }
-
-    date_vector
-}
-
 /// Computes the the time to maturity of an option in months
 pub fn time_to_maturity(timestamp: i64) -> f64{
     let current_date = chrono::Local::now().naive_local().date();

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

@@ -1,6 +1,6 @@
 [package]
 name = "finalytics-py"
-version = "0.4.1"
+version = "0.4.2"
 edition = "2021"
 readme = "README.md"
 
@@ -10,7 +10,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 finalytics = { path = "../finalytics", features = ["kaleido"] }
-polars = "0.33.2"
+polars = "0.41.3"
 tokio = { version = "1.32.0", features = ["full"] }
 pyo3 = { version = "0.20.0", features = ["extension-module", "generate-import-lib"] }
-plotly = { version = "0.8.4", package = "plotly-fork"}
+plotly = "0.9.0"

{finalytics-0.4.1 → finalytics-0.4.2}/python/src/ffi.rs

@@ -53,7 +53,7 @@ pub fn to_py_array(py: Python, pyarrow: &PyModule, array: ArrayRef) -> PyResult<
 pub fn rust_series_to_py_series(series: &Series) -> PyResult<PyObject> {
     // ensure we have a single chunk
     let series = series.rechunk();
-    let array = series.to_arrow(0);
+    let array = series.to_arrow(0, false);
 
     Python::with_gil(|py| {
         // import pyarrow