finalytics 0.2.4__tar.gz → 0.3.0__tar.gz

{finalytics-0.2.4 → finalytics-0.3.0}/PKG-INFO

@@ -1,13 +1,12 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: finalytics
-Version: 0.2.4
+Version: 0.3.0
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Dist: polars ==0.19.12
 Requires-Dist: pyarrow ==14.0.0
 Requires-Dist: ipython ==8.18.0
-License-File: LICENSE
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 
@@ -17,6 +16,8 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 ![License](https://img.shields.io/crates/l/finalytics)
 [![Homepage](https://img.shields.io/badge/homepage-finalytics.rs-blue)](https://finalytics.rs/)
 [![Documentation Status](https://readthedocs.org/projects/finalytics-py/badge/?version=latest)](https://finalytics-py.readthedocs.io/en/latest/?badge=latest)
+![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20Linux%20%7C%20MacOS-brightgreen)
+![Python Version](https://img.shields.io/badge/Python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
 ![PePy](https://static.pepy.tech/personalized-badge/finalytics?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads)
 [![CodeFactor](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics-py/badge)](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics-py)
 
@@ -48,7 +49,6 @@ print(get_symbols(query="SPY", asset_class="ETF"))
 ```
 
 ### Security Analysis
-[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Nnamdi-sys/finalytics-py/HEAD?labpath=examples%2Fsecurity_analysis.ipynb)
 
 ```python
 from finalytics import Ticker
@@ -58,7 +58,7 @@ print(ticker.get_current_price())
 print(ticker.get_summary_stats())
 print(ticker.get_price_history(start="2023-01-01", end="2023-10-31", interval="1d"))
 print(ticker.get_options_chain())
-print(ticker.get_news(start="2023-11-01", end="2023-11-10", compute_sentiment=False))
+print(ticker.get_news(compute_sentiment=False))
 print(ticker.get_income_statement())
 print(ticker.get_balance_sheet())
 print(ticker.get_cashflow_statement())
@@ -72,51 +72,16 @@ ticker.display_options_chart(risk_free_rate=0.02, chart_type="surface", display_
 ```
 
 ### Portfolio Optimization
-[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/Nnamdi-sys/finalytics-py/HEAD?labpath=examples%2Fportfolio_optimization.ipynb)
 
 ```python
 from finalytics import Portfolio
 
 portfolio = Portfolio(ticker_symbols=["AAPL", "GOOG", "MSFT", "BTC-USD"], 
-                      benchmark="^GSPC", start="2020-01-01", end="2022-01-01", interval="1d", 
+                      benchmark_symbol="^GSPC", start_date="2020-01-01", end_date="2022-01-01", interval="1d", 
                       confidence_level=0.95, risk_free_rate=0.02, max_iterations=1000, 
                       objective_function="max_sharpe")
 print(portfolio.get_optimization_results())
-portfolio.display_portfolio_charts("html")
-```
-
-### DeFi Liquidity Pools
-
-```python
-from finalytics import DefiPools
-
-defi_pools = DefiPools()
-print(f"Total Value Locked: ${defi_pools.total_value_locked:,.0f}")
-defi_pools.display_top_protocols_by_tvl(pool_symbol="USDC-USDT", num_protocols=20, display_format="html")
-defi_pools.display_top_protocols_by_apy(pool_symbol="USDC-USDT", num_protocols=20, display_format="html")
-defi_pools.display_pool_tvl_history(pool_symbol="USDC-USDT", protocol="uniswap-v3", chain="ethereum", display_format="html")
-defi_pools.display_pool_apy_history(pool_symbol="USDC-USDT", protocol="uniswap-v3", chain="ethereum", display_format="html")
-```
-
-### DeFi User Balances
-
-```python
-from finalytics import DefiBalances
-from finalytics import get_supported_protocols
-
-supported_protocols = get_supported_protocols()
-print(supported_protocols)
-
-# This function requires node.js and pnpm to be installed on the system
-# for macos: brew install node && npm install -g pnpm
-# for ubuntu: sudo apt install nodejs && npm install -g pnpm
-# for windows: https://nodejs.org/en/download/ && npm install -g pnpm
-
-defi_balances = DefiBalances(protocols=["wallet", "eigenlayer", "blast", "ether.fi"],
-                             chains=["ethereum", "arbitrum"],
-                             address="0x7ac34681f6aaeb691e150c43ee494177c0e2c183",
-                             display_format="html")
-print(defi_balances.balances)
+portfolio.display_portfolio_charts("performance", "html")
 ```
 
 

finalytics-0.3.0/README.md

@@ -0,0 +1,235 @@
+![Finalytics](https://github.com/Nnamdi-sys/finalytics/raw/main/logo-color.png)
+
+[![Crates.io](https://img.shields.io/crates/v/finalytics)](https://crates.io/crates/finalytics)
+[![Docs.rs](https://docs.rs/finalytics/badge.svg)](https://docs.rs/finalytics/)
+![License](https://img.shields.io/crates/l/finalytics)
+[![Homepage](https://img.shields.io/badge/homepage-finalytics.rs-blue)](https://finalytics.rs/)
+[![CodeFactor](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics/badge)](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics)
+
+**Finalytics** is a Rust library designed for retrieving financial data and performing security analysis and portfolio optimization.
+
+## Installation
+
+Add the following to your `Cargo.toml` file:
+
+```toml
+[dependencies]
+finalytics = {version = "0.4.0", features = ["kaleido"]}
+```
+
+Or run the following command:
+
+```bash
+cargo install finalytics --features kaleido
+```
+
+## Documentation
+
+View the library documentation on [docs.rs](https://docs.rs/finalytics/) or visit the [homepage](https://finalytics.rs/)
+
+
+### Security Analysis
+
+```rust
+use std::error::Error;
+use finalytics::prelude::*;
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn Error>> {
+
+    // Instantiate the Ticker Object
+    let ticker = TickerBuilder::new().ticker("AAPL")?
+        .start_date("2023-01-01")
+        .end_date("2023-02-01")
+        .interval(Interval::OneDay)
+        .benchmark_symbol("^GSPC")
+        .confidence_level(0.95)
+        .risk_free_rate(0.02)
+        .build()?;
+
+    // Fetch Ticker Data
+    let quote = ticker.get_quote().await?;
+    let stats = ticker.get_ticker_stats().await?;
+    let chart = ticker.get_chart().await?;
+    let options = ticker.get_options().await?;
+
+    println!("{:?}", quote);
+    println!("{:?}", stats);
+    println!("{:?}", chart);
+    println!("{:?}", options);
+
+    // Fundamental Analysis
+    let income_statement = ticker.income_statement().await?;
+    let balance_sheet = ticker.balance_sheet().await?;
+    let cash_flow = ticker.cashflow_statement().await?;
+    let financial_ratios = ticker.financial_ratios().await?;
+    let performance_stats = ticker.performance_stats().await?;
+    let volatility_surface = ticker.volatility_surface().await?;
+
+    println!("{:?}", income_statement);
+    println!("{:?}", balance_sheet);
+    println!("{:?}", cash_flow);
+    println!("{:?}", financial_ratios);
+    println!("{:?}", performance_stats);
+    println!("{:?}", volatility_surface);
+
+    // Technical Analysis
+    let sma = ticker.sma(50).await?;
+    let ema = ticker.ema(3).await?;
+    let macd = ticker.macd(12, 26, 9).await?;
+    let rsi = ticker.rsi(14).await?;
+    let fs = ticker.fs(14).await?;
+    let ss = ticker.ss(7, 3).await?;
+    let ppo = ticker.ppo(12, 26, 9).await?;
+    let roc = ticker.roc(1).await?;
+    let mfi = ticker.mfi(14).await?;
+    let bb = ticker.bb(20, 2.0).await?;
+    let sd = ticker.sd(20).await?;
+    let mad = ticker.mad(20).await?;
+    let atr = ticker.atr(14).await?;
+    let max = ticker.max(20).await?;
+    let min = ticker.min(20).await?;
+    let obv = ticker.obv().await?;
+
+    println!("SMA:{:?}\nEMA:{:?}\nMACD:{:?}\nRSI:{:?}\nFS:{:?}\nSS:{:?}\nPPO:{:?}\nROC:{:?}\nMFI:{:?}\
+            \nBB:{:?}\nSD:{:?}\nMAD:{:?}\nATR:{:?}\nMAX:{:?}\nMIN:{:?}\nOBV:{:?}\n",
+             sma, ema, macd, rsi, fs, ss, ppo, roc, mfi, bb, sd, mad, atr, max, min, obv);
+
+    // News Sentiment Analysis
+    let news_sentiment = ticker.get_news(true).await?;
+    println!("{:?}", news_sentiment);
+
+    // Display Ticker Charts
+    let candlestick_chart = ticker.candlestick_chart().await?;
+    let performance_chart = ticker.performance_chart().await?;
+    let volatility_charts = ticker.volatility_charts().await?;
+    let summary_stats_table = ticker.summary_stats_table().await?;
+    let performance_stats_table = ticker.performance_stats_table().await?;
+    let financials_tables = ticker.financials_tables().await?;
+
+    candlestick_chart.show();
+    performance_chart.show();
+    summary_stats_table.show();
+    performance_stats_table.show();
+    volatility_charts["Volatility Surface"].show();
+    volatility_charts["Volatility Smile"].show();
+    volatility_charts["Volatility Term Structure"].show();
+    financials_tables["Income Statement"].show();
+    financials_tables["Balance Sheet"].show();
+    financials_tables["Cashflow Statement"].show();
+    financials_tables["Financial Ratios"].show();
+
+    Ok(())
+
+}
+```
+
+### Portfolio Optimization
+
+```rust
+use std::error::Error;
+use finalytics::prelude::*;
+
+#[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 portfolio = PortfolioBuilder::new().ticker_symbols(ticker_symbols)
+                                            .benchmark_symbol("^GSPC")
+                                            .start_date("2017-01-01")
+                                            .end_date("2023-01-01")
+                                            .interval(Interval::OneDay)
+                                            .confidence_level(0.95)
+                                            .risk_free_rate(0.02)
+                                            .max_iterations(1000)
+                                            .objective_function(ObjectiveFunction::MaxSharpe)
+                                            .build().await?;
+
+    // Display Portfolio Optimization Results
+    println!("{:?}", portfolio.performance_stats);
+
+   // Display Portfolio Analytics Charts
+    portfolio.optimization_chart()?.show();
+    portfolio.performance_chart()?.show();
+    portfolio.asset_returns_chart()?.show();
+    portfolio.performance_stats_table()?.show();
+
+    Ok(())
+}
+```
+
+## Sample Applications
+
+<h3><a href="https://finalytics.rs/ticker">Ticker Charts Viewer</a></h3>
+
+This sample application allows you to perform security analysis based on the Finalytics Library.
+
+<h3><a href="https://finalytics.rs/portfolio">Portfolio Charts Viewer</a></h3>
+
+This sample application enables you to perform portfolio optimization based on the Finalytics Library.
+
+<h3><a href="https://t.me/finalytics_bot">Telegram Bot</a></h3>
+The Finalytics Telegram Bot allows you to perform security analysis, portfolio optimization and news sentiment analysis directly from Telegram.
+
+
+## Python Binding
+
+[![pypi](https://img.shields.io/pypi/v/finalytics)](https://pypi.org/project/finalytics/)
+![License](https://img.shields.io/crates/l/finalytics)
+[![Homepage](https://img.shields.io/badge/homepage-finalytics.rs-blue)](https://finalytics.rs/)
+[![Documentation Status](https://readthedocs.org/projects/finalytics-py/badge/?version=latest)](https://finalytics-py.readthedocs.io/en/latest/?badge=latest)
+![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20Linux%20%7C%20MacOS-brightgreen)
+![Python Version](https://img.shields.io/badge/Python-3.7%20%7C%203.8%20%7C%203.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
+![PePy](https://static.pepy.tech/personalized-badge/finalytics?period=total&units=international_system&left_color=black&right_color=blue&left_text=Downloads)
+[![CodeFactor](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics-py/badge)](https://www.codefactor.io/repository/github/nnamdi-sys/finalytics-py)
+
+
+## Installation
+
+```bash
+pip install finalytics
+```
+
+## Documentation
+
+View Library documentation on readthedocs [here](https://finalytics-py.readthedocs.io/en/latest/)
+
+
+### Security Analysis
+
+```python
+from finalytics import Ticker
+
+ticker = Ticker(symbol="AAPL")
+print(ticker.get_current_price())
+print(ticker.get_summary_stats())
+print(ticker.get_price_history(start="2023-01-01", end="2023-10-31", interval="1d"))
+print(ticker.get_options_chain())
+print(ticker.get_news(compute_sentiment=True))
+print(ticker.get_income_statement())
+print(ticker.get_balance_sheet())
+print(ticker.get_cashflow_statement())
+print(ticker.get_financial_ratios())
+print(ticker.compute_performance_stats(start="2023-01-01", end="2023-10-31", interval="1d", benchmark="^GSPC", 
+                                       confidence_level=0.95, risk_free_rate=0.02))
+ticker.display_performance_chart(start="2023-01-01", end="2023-10-31", interval="1d", benchmark="^GSPC", 
+                                 confidence_level=0.95, risk_free_rate=0.02, display_format="notebook")
+ticker.display_candlestick_chart(start="2023-01-01", end="2023-10-31", interval="1d", display_format="html")
+ticker.display_options_chart(risk_free_rate=0.02, chart_type="surface", display_format="png")
+```
+
+### Portfolio Optimization
+
+```python
+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", 
+                      confidence_level=0.95, risk_free_rate=0.02, max_iterations=1000, 
+                      objective_function="max_sharpe")
+print(portfolio.get_optimization_results())
+portfolio.display_portfolio_charts("performance", "html")
+```
+
+
+

finalytics-0.3.0/finalytics/Cargo.toml

@@ -0,0 +1,50 @@
+[package]
+name = "finalytics"
+version = "0.4.0"
+authors = ["Nnamdi Olisaeloka <nnamdiolisaeloka@gmail.com>"]
+edition = "2021"
+homepage = "https://finalytics.rs/"
+repository = "https://github.com/Nnamdi-sys/finalytics"
+license = "MIT"
+description = "A rust library for financial data analysis"
+readme = "../README.md"
+keywords = ["finance", "analytics"]
+
+[lib]
+path = "src/lib.rs"
+
+
+[dependencies]
+openssl = { version = "0.10.64", features = ["vendored"] }
+serde = { version = "1.0.197", features = ["derive"] }
+serde_json = "1.0.115"
+reqwest = { version = "0.12.2", features = ["json"] }
+tokio = { version = "1.32.0", features = ["full"] }
+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"] }
+ta = "0.5.0"
+num-format = "0.4.4"
+smartcore = "0.3.2"
+statrs = "0.16.0"
+rand = "0.8.5"
+ndarray = "0.15.6"
+rand_distr = "0.4.3"
+optimization = "0.2.0"
+rusqlite = { version = "0.31.0", features = ["bundled"] }
+lazy_static = "1.4.0"
+r2d2 = "0.8.10"
+r2d2_sqlite = "0.24.0"
+html-escape = "0.2.13"
+plotly = { version = "0.8.4", package = "plotly-fork"}
+
+[features]
+kaleido = ["plotly/kaleido"]
+
+
+
+
+
+

finalytics-0.3.0/finalytics/src/analytics/fundamentals.rs

@@ -0,0 +1,282 @@
+use std::collections::HashMap;
+use std::error::Error;
+use polars::prelude::*;
+use crate::data::ticker::TickerData;
+use crate::models::ticker::Ticker;
+
+pub trait Financials {
+    fn financial_ratios(&self) -> impl std::future::Future<Output = Result<DataFrame, Box<dyn Error>>>;
+    fn income_statement(&self) -> impl std::future::Future<Output = Result<DataFrame, Box<dyn Error>>>;
+    fn balance_sheet(&self) -> impl std::future::Future<Output = Result<DataFrame, Box<dyn Error>>>;
+    fn cashflow_statement(&self) -> impl std::future::Future<Output = Result<DataFrame, Box<dyn Error>>>;
+}
+
+impl Financials for Ticker {
+    /// Computes financial ratios
+    ///
+    /// # Returns
+    ///
+    /// * `Financials` struct
+    async fn financial_ratios(&self) -> Result<DataFrame, Box<dyn Error>>{
+        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 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_cash_flow" => *&balance_sheet.column("TotalCapitalization")? / *&cash_flow.column("OperatingCashFlow")?,
+            "price_to_free_cash_flow" => *&balance_sheet.column("TotalCapitalization")? / *&cash_flow.column("FreeCashFlow")?,
+        )?;
+
+        // 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 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)?;
+        Ok(transposed_df)
+    }
+
+    /// Formats the income statement
+    ///
+    /// # Returns
+    ///
+    /// * `DataFrame` - Formatted income statement
+    async fn income_statement(&self) -> Result<DataFrame, Box<dyn Error>> {
+        let income_statement = self.get_fundamentals("income-statement", "quarterly").await?;
+        
+        let mut ifrs_mapping = HashMap::new();
+        ifrs_mapping.insert("TotalRevenue", "Revenue");
+        ifrs_mapping.insert("GrossProfit", "Gross Profit");
+        ifrs_mapping.insert("OperatingExpense", "Operating Expenses");
+        ifrs_mapping.insert("NetIncome", "Net Income");
+        ifrs_mapping.insert("TaxProvision", "Income Tax Expense");
+        ifrs_mapping.insert("BasicEPS", "Earnings per Share - Basic");
+        ifrs_mapping.insert("DilutedEPS", "Earnings per Share - Diluted");
+        ifrs_mapping.insert("EBIT", "Operating Profit (EBIT)");
+        ifrs_mapping.insert("EBITDA", "EBITDA");
+        ifrs_mapping.insert("ReconciledCostOfRevenue", "Cost of Goods Sold");
+        ifrs_mapping.insert("ReconciledDepreciation", "Depreciation and Amortization");
+        ifrs_mapping.insert("InterestIncome", "Interest Income");
+        ifrs_mapping.insert("InterestExpense", "Interest Expense");
+
+        let mut cols = vec![
+            "TotalRevenue", "ReconciledCostOfRevenue", "GrossProfit", "OperatingExpense",
+            "EBITDA", "ReconciledDepreciation", "EBIT", "InterestIncome", "InterestExpense",
+            "TaxProvision", "NetIncome", "BasicEPS", "DilutedEPS",
+        ];
+
+        // remove item from cols if it doesnt exist in the income statement dataframe
+        cols.retain(|x| income_statement.column(*x).is_ok());
+
+        let df = income_statement.clone().select(&cols)?;
+
+        // Create a vector of expressions for renaming and selecting columns
+        let expressions: Vec<Expr> = cols
+            .iter()
+            .map(|old_name| {
+                let new_name = ifrs_mapping.get(*old_name).unwrap_or(old_name);
+                col(*old_name).alias(new_name)
+            })
+            .collect();
+
+        // Select and alias columns using the expressions
+        let 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 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)?;
+        Ok(transposed_df)
+    }
+
+    /// Formats the balance sheet
+    ///
+    /// # Returns
+    ///
+    /// * `DataFrame` - Formatted balance sheet
+    async fn balance_sheet(&self) -> Result<DataFrame, Box<dyn Error>> {
+        let balance_sheet = self.get_fundamentals("balance-sheet", "quarterly").await?;
+        
+        let mut ifrs_mapping = HashMap::new();
+
+        // Assets
+        ifrs_mapping.insert("CashAndCashEquivalents", "Cash and Cash Equivalents");
+        ifrs_mapping.insert("AccountsReceivable", "Accounts Receivable");
+        ifrs_mapping.insert("Inventory", "Inventories");
+        ifrs_mapping.insert("OtherCurrentAssets", "Other Current Assets");
+        ifrs_mapping.insert("CurrentAssets", "Total Current Assets");
+        ifrs_mapping.insert("NetPPE", "Property, Plant, and Equipment (Net)");
+        ifrs_mapping.insert("GoodwillAndOtherIntangibleAssets", "Intangible Assets");
+        ifrs_mapping.insert("OtherNonCurrentAssets", "Other Non-Current Assets");
+        ifrs_mapping.insert("TotalNonCurrentAssets", "Total Non-Current Assets");
+        ifrs_mapping.insert("TotalAssets", "Total Assets");
+
+        // Liabilities
+        ifrs_mapping.insert("AccountsPayable", "Accounts Payable");
+        ifrs_mapping.insert("CurrentDebt", "Short-Term Debt");
+        ifrs_mapping.insert("OtherCurrentLiabilities", "Other Current Liabilities");
+        ifrs_mapping.insert("CurrentLiabilities", "Total Current Liabilities");
+        ifrs_mapping.insert("LongTermDebt", "Long-Term Debt");
+        ifrs_mapping.insert("OtherNonCurrentLiabilities", "Other Non-Current Liabilities");
+        ifrs_mapping.insert("TotalNonCurrentLiabilitiesNetMinorityInterest", "Total Non-Current Liabilities");
+        ifrs_mapping.insert("TotalLiabilitiesNetMinorityInterest", "Total Liabilities");
+
+        // Equity
+        ifrs_mapping.insert("CommonStock", "Common Stock");
+        ifrs_mapping.insert("RetainedEarnings", "Retained Earnings");
+        ifrs_mapping.insert("CommonStockEquity", "Total Equity");
+        ifrs_mapping.insert("TotalEquityGrossMinorityInterest", "Total Liabilities and Equity");
+
+        let mut cols = vec![
+            "CashAndCashEquivalents", "AccountsReceivable", "Inventory", "OtherCurrentAssets",
+            "CurrentAssets", "NetPPE", "GoodwillAndOtherIntangibleAssets",
+            "OtherNonCurrentAssets", "TotalNonCurrentAssets", "TotalAssets",
+            "AccountsPayable", "CurrentDebt", "OtherCurrentLiabilities", "CurrentLiabilities", "LongTermDebt",
+            "OtherNonCurrentLiabilities", "TotalNonCurrentLiabilitiesNetMinorityInterest", "TotalLiabilitiesNetMinorityInterest",
+            "CommonStock", "RetainedEarnings", "CommonStockEquity", "TotalEquityGrossMinorityInterest",
+        ];
+
+        // remove item from cols if it doesnt exist in the balance sheet dataframe
+        cols.retain(|x| balance_sheet.column(*x).is_ok());
+
+
+        let df = balance_sheet.clone().select(&cols)?;
+
+        // Create a vector of expressions for renaming and selecting columns
+        let expressions: Vec<Expr> = cols
+            .iter()
+            .map(|old_name| {
+                let new_name = ifrs_mapping.get(*old_name).unwrap_or(old_name);
+                col(*old_name).alias(new_name)
+            })
+            .collect();
+
+        // Select and alias columns using the expressions
+        let 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 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)?;
+
+        Ok(transposed_df)
+
+    }
+
+    /// Formats the cash flow statement
+    ///
+    /// # Returns
+    ///
+    /// * `DataFrame` - Formatted cash flow statement
+    async fn cashflow_statement(&self) -> Result<DataFrame, Box<dyn Error>> {
+        let cash_flow = self.get_fundamentals("cash-flow", "quarterly").await?;
+        
+        let mut ifrs_mapping = HashMap::new();
+
+        // Operating Activities
+        ifrs_mapping.insert("NetIncomeFromContinuingOperations", "Net Income from Continuing Operations");
+        ifrs_mapping.insert("DepreciationAmortizationDepletion", "Depreciation, Amortization, and Depletion");
+        ifrs_mapping.insert("StockBasedCompensation", "Stock-Based Compensation");
+        ifrs_mapping.insert("DeferredIncomeTax", "Deferred Income Tax");
+        ifrs_mapping.insert("ChangeInWorkingCapital", "Changes in Working Capital");
+        ifrs_mapping.insert("CashFlowFromContinuingOperatingActivities", "Cash Flow from Continuing Operating Activities");
+
+        // Investing Activities
+        ifrs_mapping.insert("PurchaseOfPPE", "Purchase of Property, Plant, and Equipment");
+        ifrs_mapping.insert("PurchaseOfBusiness", "Purchase of Business");
+        ifrs_mapping.insert("NetInvestmentPurchaseAndSale", "Net Investment Purchase and Sale");
+        ifrs_mapping.insert("SaleOfInvestment", "Sale of Investment");
+        ifrs_mapping.insert("PurchaseOfInvestment", "Purchase of Investment");
+        ifrs_mapping.insert("NetOtherInvestingChanges", "Net Other Investing Changes");
+        ifrs_mapping.insert("CashFlowFromContinuingInvestingActivities", "Cash Flow from Continuing Investing Activities");
+
+        // Financing Activities
+        ifrs_mapping.insert("IssuanceOfCapitalStock", "Issuance of Capital Stock");
+        ifrs_mapping.insert("CommonStockIssuance", "Common Stock Issuance");
+        ifrs_mapping.insert("NetCommonStockIssuance", "Net Common Stock Issuance");
+        ifrs_mapping.insert("CommonStockDividendPaid", "Common Stock Dividend Paid");
+        ifrs_mapping.insert("CashDividendsPaid", "Cash Dividends Paid");
+        ifrs_mapping.insert("RepurchaseOfCapitalStock", "Repurchase of Capital Stock");
+        ifrs_mapping.insert("LongTermDebtPayments", "Long-Term Debt Payments");
+        ifrs_mapping.insert("NetLongTermDebtIssuance", "Net Long-Term Debt Issuance");
+        ifrs_mapping.insert("NetIssuancePaymentsOfDebt", "Net Issuance/Payments of Debt");
+        ifrs_mapping.insert("NetOtherFinancingCharges", "Net Other Financing Charges");
+        ifrs_mapping.insert("CashFlowFromContinuingFinancingActivities", "Cash Flow from Continuing Financing Activities");
+
+        // Summary
+        ifrs_mapping.insert("BeginningCashPosition", "Beginning Cash Position");
+        ifrs_mapping.insert("OperatingCashFlow", "Operating Cash Flow");
+        ifrs_mapping.insert("InvestingCashFlow", "Investing Cash Flow");
+        ifrs_mapping.insert("FinancingCashFlow", "Financing Cash Flow");
+        ifrs_mapping.insert("EndCashPosition", "Ending Cash Position");
+        ifrs_mapping.insert("FreeCashFlow", "Free Cash Flow");
+
+
+        let mut cols = vec![
+            "NetIncomeFromContinuingOperations", "DepreciationAmortizationDepletion", "StockBasedCompensation",
+            "DeferredIncomeTax", "ChangeInWorkingCapital", "CashFlowFromContinuingOperatingActivities",
+            "PurchaseOfPPE", "PurchaseOfBusiness", "NetInvestmentPurchaseAndSale", "SaleOfInvestment", "PurchaseOfInvestment",
+            "NetOtherInvestingChanges", "CashFlowFromContinuingInvestingActivities", "IssuanceOfCapitalStock",
+            "CommonStockIssuance", "NetCommonStockIssuance", "CommonStockDividendPaid", "CashDividendsPaid",
+            "RepurchaseOfCapitalStock", "LongTermDebtPayments", "NetLongTermDebtIssuance", "NetIssuancePaymentsOfDebt",
+            "NetOtherFinancingCharges", "CashFlowFromContinuingFinancingActivities", "EffectOfExchangeRateChanges",
+            "BeginningCashPosition", "OperatingCashFlow", "InvestingCashFlow", "FinancingCashFlow", "EndCashPosition", "FreeCashFlow",
+        ];
+
+        // remove item from cols if it doesnt exist in the cash flow dataframe
+        cols.retain(|x| cash_flow.column(*x).is_ok());
+
+
+        let df = cash_flow.clone().select(&cols)?;
+
+        // Create a vector of expressions for renaming and selecting columns
+        let expressions: Vec<Expr> = cols
+            .iter()
+            .map(|old_name| {
+                let new_name = ifrs_mapping.get(*old_name).unwrap_or(old_name);
+                col(*old_name).alias(new_name)
+            })
+            .collect();
+
+        // Select and alias columns using the expressions
+        let 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 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)?;
+
+        Ok(transposed_df)
+    }
+}