Upload 5 files

app.py

@@ -0,0 +1,404 @@
+import gradio as gr
+import pandas as pd
+import matplotlib.pyplot as plt
+import numpy as np
+from data_fetcher import DataFetcher
+from valuation import DCFValuation
+from utils import (format_number, format_metrics_table, create_price_chart, 
+                  format_financial_statement, create_financial_chart, create_spider_chart,
+                  prepare_financial_table, create_key_metrics_chart, create_growth_chart,
+                  create_margin_chart, create_multi_year_growth_chart, create_ratio_chart)
+
+# Initialize classes
+data_fetcher = DataFetcher()
+dcf_valuation = DCFValuation()
+
+def analyze_stock(ticker, growth_rate, discount_rate, projection_years, format_type):
+    # Close any existing matplotlib figures to prevent memory issues
+    plt.close('all')
+
+    try:
+        # Validate inputs
+        if not ticker:
+            return {"error": "Please enter a ticker symbol"}, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None
+
+        ticker = ticker.upper().strip()
+
+        # Fetch data
+        metrics = data_fetcher.get_key_metrics(ticker)
+        price_history = data_fetcher.get_price_history(ticker)
+        financial_statements = data_fetcher.get_financial_statements(ticker)
+
+        # Get currency symbol
+        currency_symbol = metrics.get('Currency Symbol', '$')
+
+        # Format metrics for display
+        formatted_metrics = format_metrics_table(metrics)
+
+        # Calculate DCF valuation
+        try:
+            fcf = data_fetcher.get_free_cash_flow(ticker)
+            shares_outstanding = metrics.get('Shares Outstanding', None)
+
+            if fcf is not None and shares_outstanding and shares_outstanding != 'N/A':
+                company_value = dcf_valuation.calculate_dcf(
+                    fcf=fcf,
+                    growth_rate=growth_rate/100,  # Convert percentage to decimal
+                    discount_rate=discount_rate/100,  # Convert percentage to decimal
+                    years=int(projection_years)
+                )
+
+                # Format valuation results
+                valuation_results = {
+                    "Company Value": format_number(company_value, currency_symbol=currency_symbol, format_type=format_type),
+                    "Current Market Cap": formatted_metrics.get("Market Cap", "N/A"),
+                    "Free Cash Flow": format_number(fcf, currency_symbol=currency_symbol, format_type=format_type),
+                    "Growth Rate": f"{growth_rate:.1f}%",
+                    "Discount Rate": f"{discount_rate:.1f}%",
+                    "Projection Years": int(projection_years)
+                }
+
+                if shares_outstanding:
+                    per_share_value = dcf_valuation.calculate_per_share_value(company_value, shares_outstanding)
+                    current_price = metrics.get('Current Price', None)
+
+                    valuation_results["Estimated Share Value"] = f"{currency_symbol}{per_share_value:.2f}"
+                    valuation_results["Current Share Price"] = f"{currency_symbol}{current_price:.2f}" if current_price else "N/A"
+
+                    if current_price:
+                        upside = (per_share_value / current_price - 1) * 100
+                        valuation_results["Potential Upside"] = f"{upside:.1f}%"
+            else:
+                valuation_results = {"error": f"Insufficient data for DCF valuation. FCF: {fcf}, Shares: {shares_outstanding}"}
+        except Exception as e:
+            valuation_results = {"error": f"Valuation error: {str(e)}"}
+
+        # Create price chart
+        price_fig = create_price_chart(price_history)
+
+        # Create spider chart with enhanced metrics
+        spider_fig = create_spider_chart(metrics, f"{ticker} Financial Metrics")
+
+        # Prepare financial statements for display - Annual
+        annual_income_table = prepare_financial_table(
+            financial_statements['income_stmt'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        annual_balance_table = prepare_financial_table(
+            financial_statements['balance_sheet'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        annual_cash_flow_table = prepare_financial_table(
+            financial_statements['cash_flow'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        # Prepare financial statements for display - Quarterly
+        quarterly_income_table = prepare_financial_table(
+            financial_statements['quarterly_income_stmt'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        quarterly_balance_table = prepare_financial_table(
+            financial_statements['quarterly_balance_sheet'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        quarterly_cash_flow_table = prepare_financial_table(
+            financial_statements['quarterly_cash_flow'], 
+            currency_symbol=currency_symbol,
+            format_type=format_type
+        )
+
+        # Create financial charts with error handling
+        try:
+            income_fig = create_financial_chart(financial_statements['income_stmt'], 
+                                               f"{ticker} Income Statement", 'bar')
+        except Exception as e:
+            income_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Error creating income statement chart: {str(e)}", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            balance_fig = create_financial_chart(financial_statements['balance_sheet'], 
+                                                f"{ticker} Balance Sheet", 'bar')
+        except Exception as e:
+            balance_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Error creating balance sheet chart: {str(e)}", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            cash_flow_fig = create_financial_chart(financial_statements['cash_flow'], 
+                                                  f"{ticker} Cash Flow", 'bar')
+        except Exception as e:
+            cash_flow_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Error creating cash flow chart: {str(e)}", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        # Create quarterly financial charts with error handling
+        try:
+            q_income_fig = create_financial_chart(financial_statements['quarterly_income_stmt'], 
+                                                 f"{ticker} Quarterly Income Statement", 'bar')
+        except Exception as e:
+            q_income_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Quarterly income data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            q_balance_fig = create_financial_chart(financial_statements['quarterly_balance_sheet'], 
+                                                  f"{ticker} Quarterly Balance Sheet", 'bar')
+        except Exception as e:
+            q_balance_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Quarterly balance sheet data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            q_cash_flow_fig = create_financial_chart(financial_statements['quarterly_cash_flow'], 
+                                                    f"{ticker} Quarterly Cash Flow", 'bar')
+        except Exception as e:
+            q_cash_flow_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Quarterly cash flow data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        # Create additional analysis charts with error handling
+        try:
+            revenue_growth_fig = create_growth_chart(
+                financial_statements['income_stmt'], 
+                'Total Revenue', 
+                f"{ticker} Revenue Growth"
+            )
+        except Exception as e:
+            revenue_growth_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Revenue growth data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            margin_fig = create_margin_chart(
+                financial_statements['income_stmt'],
+                f"{ticker} Margin Analysis"
+            )
+        except Exception as e:
+            margin_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Margin analysis data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        # Create key metrics charts with error handling
+        try:
+            key_metrics_income = create_key_metrics_chart(
+                financial_statements['income_stmt'],
+                f"{ticker} Key Income Metrics",
+                ['Total Revenue', 'Gross Profit', 'Operating Income', 'Net Income'],
+                currency_symbol
+            )
+        except Exception as e:
+            key_metrics_income = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Income metrics data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            key_metrics_balance = create_key_metrics_chart(
+                financial_statements['balance_sheet'],
+                f"{ticker} Key Balance Sheet Metrics",
+                ['Total Assets', 'Total Liabilities Net Minority Interest', 'Total Equity Gross Minority Interest'],
+                currency_symbol
+            )
+        except Exception as e:
+            key_metrics_balance = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Balance sheet metrics data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            key_metrics_cash = create_key_metrics_chart(
+                financial_statements['cash_flow'],
+                f"{ticker} Key Cash Flow Metrics",
+                ['Operating Cash Flow', 'Free Cash Flow', 'Capital Expenditures'],
+                currency_symbol
+            )
+        except Exception as e:
+            key_metrics_cash = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Cash flow metrics data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        # Create ratio charts with error handling
+        try:
+            profitability_fig = create_ratio_chart(
+                financial_statements['income_stmt'],
+                f"{ticker} Profitability Ratios",
+                'profitability'
+            )
+        except Exception as e:
+            profitability_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Profitability ratio data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        try:
+            efficiency_fig = create_ratio_chart(
+                financial_statements['balance_sheet'],
+                f"{ticker} Efficiency Ratios",
+                'efficiency'
+            )
+        except Exception as e:
+            efficiency_fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, f"Efficiency ratio data not available", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=12)
+            plt.axis('off')
+
+        return (formatted_metrics, valuation_results, price_fig, 
+                annual_income_table, annual_balance_table, annual_cash_flow_table,
+                quarterly_income_table, quarterly_balance_table, quarterly_cash_flow_table,
+                income_fig, balance_fig, cash_flow_fig,
+                q_income_fig, q_balance_fig, q_cash_flow_fig,
+                spider_fig, revenue_growth_fig, margin_fig,
+                key_metrics_income, key_metrics_balance, key_metrics_cash,
+                profitability_fig)
+
+    except Exception as e:
+        error_msg = {"error": f"Error: {str(e)}"}
+        # Create empty figures for all plots
+        empty_fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, f"Error: {str(e)}", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+
+        return (error_msg, {"error": str(e)}, empty_fig, 
+                {"error": "Data unavailable"}, {"error": "Data unavailable"}, {"error": "Data unavailable"},
+                {"error": "Data unavailable"}, {"error": "Data unavailable"}, {"error": "Data unavailable"},
+                empty_fig, empty_fig, empty_fig, empty_fig, empty_fig, empty_fig, 
+                empty_fig, empty_fig, empty_fig, empty_fig, empty_fig, empty_fig, empty_fig)
+
+# Create Gradio interface
+with gr.Blocks(title="Stock DCF Valuation Tool") as app:
+    gr.Markdown("# Stock DCF Valuation Tool")
+    gr.Markdown("Enter a stock ticker and DCF assumptions to get a valuation")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            ticker_input = gr.Textbox(label="Stock Ticker (e.g., AAPL, RELIANCE.NS)", placeholder="Enter ticker...")
+
+            with gr.Row():
+                growth_rate = gr.Slider(minimum=0, maximum=250, value=15, step=1, label="Growth Rate (%)")
+                discount_rate = gr.Slider(minimum=5, maximum=20, value=10, step=0.1, label="Discount Rate (%)")
+
+            projection_years = gr.Slider(minimum=1, maximum=10, value=5, step=1, label="Projection Years")
+
+            format_type = gr.Radio(
+                ["auto", "comma", "millions", "billions"], 
+                label="Number Format", 
+                value="millions"
+            )
+
+            analyze_button = gr.Button("Analyze Stock", variant="primary")
+
+        with gr.Column(scale=2):
+            with gr.Tabs():
+                with gr.TabItem("Key Metrics"):
+                    metrics_output = gr.JSON(label="Key Metrics")
+                    spider_chart = gr.Plot(label="Financial Metrics Radar")
+
+                with gr.TabItem("DCF Valuation"):
+                    valuation_output = gr.JSON(label="DCF Valuation Results")
+                    price_chart = gr.Plot(label="Price History")
+
+                with gr.TabItem("Annual Financials"):
+                    with gr.Tabs():
+                        with gr.TabItem("Income Statement"):
+                            income_chart = gr.Plot(label="Income Statement Chart")
+                            annual_income_output = gr.JSON(label="Annual Income Statement")
+
+                        with gr.TabItem("Balance Sheet"):
+                            balance_chart = gr.Plot(label="Balance Sheet Chart")
+                            annual_balance_output = gr.JSON(label="Annual Balance Sheet")
+
+                        with gr.TabItem("Cash Flow"):
+                            cash_flow_chart = gr.Plot(label="Cash Flow Chart")
+                            annual_cash_flow_output = gr.JSON(label="Annual Cash Flow")
+
+                with gr.TabItem("Quarterly Financials"):
+                    with gr.Tabs():
+                        with gr.TabItem("Income Statement"):
+                            q_income_chart = gr.Plot(label="Quarterly Income Statement Chart")
+                            quarterly_income_output = gr.JSON(label="Quarterly Income Statement")
+
+                        with gr.TabItem("Balance Sheet"):
+                            q_balance_chart = gr.Plot(label="Quarterly Balance Sheet Chart")
+                            quarterly_balance_output = gr.JSON(label="Quarterly Balance Sheet")
+
+                        with gr.TabItem("Cash Flow"):
+                            q_cash_flow_chart = gr.Plot(label="Quarterly Cash Flow Chart")
+                            quarterly_cash_flow_output = gr.JSON(label="Quarterly Cash Flow")
+
+                with gr.TabItem("Financial Analysis"):
+                    with gr.Tabs():
+                        with gr.TabItem("Revenue & Growth"):
+                            revenue_growth_chart = gr.Plot(label="Revenue Growth")
+                            key_metrics_income_chart = gr.Plot(label="Key Income Metrics")
+
+                        with gr.TabItem("Profitability"):
+                            margin_chart = gr.Plot(label="Margin Analysis")
+                            profitability_chart = gr.Plot(label="Profitability Ratios")
+
+                        with gr.TabItem("Balance Sheet Analysis"):
+                            key_metrics_balance_chart = gr.Plot(label="Key Balance Sheet Metrics")
+                            efficiency_chart = gr.Plot(label="Efficiency Ratios")
+
+                        with gr.TabItem("Cash Flow Analysis"):
+                            key_metrics_cash_chart = gr.Plot(label="Key Cash Flow Metrics")
+
+    # Define function to clear figures when app is closed
+    def on_close():
+        plt.close('all')
+
+    # Register the function to be called when the app is closed
+    app.load(on_close)
+
+    analyze_button.click(
+        analyze_stock,
+        inputs=[ticker_input, growth_rate, discount_rate, projection_years, format_type],
+        outputs=[
+            metrics_output, 
+            valuation_output, 
+            price_chart,
+            annual_income_output,
+            annual_balance_output,
+            annual_cash_flow_output,
+            quarterly_income_output,
+            quarterly_balance_output,
+            quarterly_cash_flow_output,
+            income_chart,
+            balance_chart,
+            cash_flow_chart,
+            q_income_chart,
+            q_balance_chart,
+            q_cash_flow_chart,
+            spider_chart,
+            revenue_growth_chart,
+            margin_chart,
+            key_metrics_income_chart,
+            key_metrics_balance_chart,
+            key_metrics_cash_chart,
+            profitability_chart
+        ]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    app.launch()

data_fetcher.py

@@ -0,0 +1,232 @@
+import yfinance as yf
+import pandas as pd
+import numpy as np
+from datetime import datetime, timedelta
+
+class DataFetcher:
+    def __init__(self):
+        # Cache to store fetched data
+        self.cache = {}
+
+    def get_ticker_info(self, ticker):
+        """Get basic information about a ticker"""
+        cache_key = f"{ticker}_info"
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        try:
+            stock = yf.Ticker(ticker)
+            info = stock.info
+            self.cache[cache_key] = info
+            return info
+        except Exception as e:
+            print(f"Error fetching info for {ticker}: {str(e)}")
+            return {}
+
+    def get_price_history(self, ticker, period="1y"):
+        """Get historical price data for a ticker"""
+        cache_key = f"{ticker}_price_{period}"
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        try:
+            stock = yf.Ticker(ticker)
+            history = stock.history(period=period)
+
+            if history.empty:
+                # Try with a shorter period if 1y fails
+                history = stock.history(period="6mo")
+
+            if history.empty:
+                # Try with an even shorter period if 6mo fails
+                history = stock.history(period="3mo")
+
+            if not history.empty:
+                # Use Close prices
+                price_series = history['Close']
+                self.cache[cache_key] = price_series
+                return price_series
+            else:
+                print(f"No price history available for {ticker}")
+                return pd.Series()
+        except Exception as e:
+            print(f"Error fetching price history for {ticker}: {str(e)}")
+            return pd.Series()
+
+    def get_key_metrics(self, ticker):
+        """Get key financial metrics for a ticker"""
+        cache_key = f"{ticker}_metrics"
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        try:
+            stock = yf.Ticker(ticker)
+            info = stock.info
+
+            # Determine currency symbol based on country or exchange
+            currency_symbol = '$'  # Default to USD
+            if 'currency' in info:
+                if info['currency'] == 'INR':
+                    currency_symbol = '₹'
+                elif info['currency'] == 'EUR':
+                    currency_symbol = '€'
+                elif info['currency'] == 'GBP':
+                    currency_symbol = '£'
+                elif info['currency'] == 'JPY':
+                    currency_symbol = '¥'
+
+            # Check if it's an Indian stock based on ticker suffix
+            if ticker.endswith('.NS') or ticker.endswith('.BO'):
+                currency_symbol = '₹'
+
+            # Extract key metrics
+            metrics = {
+                'Company Name': info.get('longName', 'N/A'),
+                'Sector': info.get('sector', 'N/A'),
+                'Industry': info.get('industry', 'N/A'),
+                'Country': info.get('country', 'N/A'),
+                'Currency Symbol': currency_symbol,
+                'Current Price': info.get('currentPrice', info.get('regularMarketPrice', 'N/A')),
+                'Market Cap': info.get('marketCap', 'N/A'),
+                'P/E Ratio': info.get('trailingPE', 'N/A'),
+                'Forward P/E': info.get('forwardPE', 'N/A'),
+                'P/B Ratio': info.get('priceToBook', 'N/A'),
+                'EV/EBITDA': info.get('enterpriseToEbitda', 'N/A'),
+                'EV/Revenue': info.get('enterpriseToRevenue', 'N/A'),
+                'PEG Ratio': info.get('pegRatio', 'N/A'),
+                'Dividend Yield (%)': info.get('dividendYield', 'N/A') * 100 if info.get('dividendYield') is not None else 'N/A',
+                'EPS': info.get('trailingEps', 'N/A'),
+                'Profit Margin': info.get('profitMargins', 'N/A') * 100 if info.get('profitMargins') is not None else 'N/A',
+                'Operating Margin': info.get('operatingMargins', 'N/A') * 100 if info.get('operatingMargins') is not None else 'N/A',
+                'ROE': info.get('returnOnEquity', 'N/A') * 100 if info.get('returnOnEquity') is not None else 'N/A',
+                'ROA': info.get('returnOnAssets', 'N/A') * 100 if info.get('returnOnAssets') is not None else 'N/A',
+                'Revenue Growth': info.get('revenueGrowth', 'N/A') * 100 if info.get('revenueGrowth') is not None else 'N/A',
+                'Earnings Growth': info.get('earningsGrowth', 'N/A') * 100 if info.get('earningsGrowth') is not None else 'N/A',
+                'Debt to Equity': info.get('debtToEquity', 'N/A') / 100 if info.get('debtToEquity') is not None else 'N/A',
+                'Current Ratio': info.get('currentRatio', 'N/A'),
+                'Quick Ratio': info.get('quickRatio', 'N/A'),
+                'Beta': info.get('beta', 'N/A'),
+                '52 Week High': info.get('fiftyTwoWeekHigh', 'N/A'),
+                '52 Week Low': info.get('fiftyTwoWeekLow', 'N/A'),
+                '50-Day MA': info.get('fiftyDayAverage', 'N/A'),
+                '200-Day MA': info.get('twoHundredDayAverage', 'N/A'),
+                'Shares Outstanding': info.get('sharesOutstanding', 'N/A'),
+                'Free Cash Flow': info.get('freeCashflow', 'N/A'),
+                'Operating Cash Flow': info.get('operatingCashflow', 'N/A'),
+                'Revenue Per Share': info.get('revenuePerShare', 'N/A'),
+                'Target Mean Price': info.get('targetMeanPrice', 'N/A'),
+                'Payout Ratio': info.get('payoutRatio', 'N/A') * 100 if info.get('payoutRatio') is not None else 'N/A',
+                'EBITDA Margins': info.get('ebitdaMargins', 'N/A') * 100 if info.get('ebitdaMargins') is not None else 'N/A',
+                'Gross Margins': info.get('grossMargins', 'N/A') * 100 if info.get('grossMargins') is not None else 'N/A'
+            }
+
+            self.cache[cache_key] = metrics
+            return metrics
+        except Exception as e:
+            print(f"Error fetching metrics for {ticker}: {str(e)}")
+            return {'error': str(e), 'Currency Symbol': '$'}
+
+    def get_financial_statements(self, ticker):
+        """Get financial statements for a ticker"""
+        cache_key = f"{ticker}_financials"
+        if cache_key in self.cache:
+            return self.cache[cache_key]
+
+        try:
+            stock = yf.Ticker(ticker)
+
+            # Get annual financial statements
+            income_stmt = stock.income_stmt
+            balance_sheet = stock.balance_sheet
+            cash_flow = stock.cashflow
+
+            # Get quarterly financial statements with error handling
+            try:
+                quarterly_income_stmt = stock.quarterly_income_stmt
+            except Exception as e:
+                print(f"Error fetching quarterly income statement for {ticker}: {str(e)}")
+                quarterly_income_stmt = pd.DataFrame()
+
+            try:
+                quarterly_balance_sheet = stock.quarterly_balance_sheet
+            except Exception as e:
+                print(f"Error fetching quarterly balance sheet for {ticker}: {str(e)}")
+                quarterly_balance_sheet = pd.DataFrame()
+
+            try:
+                quarterly_cash_flow = stock.quarterly_cashflow
+            except Exception as e:
+                print(f"Error fetching quarterly cash flow for {ticker}: {str(e)}")
+                quarterly_cash_flow = pd.DataFrame()
+
+            # Package all statements
+            financial_statements = {
+                'income_stmt': income_stmt,
+                'balance_sheet': balance_sheet,
+                'cash_flow': cash_flow,
+                'quarterly_income_stmt': quarterly_income_stmt,
+                'quarterly_balance_sheet': quarterly_balance_sheet,
+                'quarterly_cash_flow': quarterly_cash_flow
+            }
+
+            self.cache[cache_key] = financial_statements
+            return financial_statements
+        except Exception as e:
+            print(f"Error fetching financial statements for {ticker}: {str(e)}")
+            # Return empty DataFrames for all statements
+            empty_df = pd.DataFrame()
+            return {
+                'income_stmt': empty_df,
+                'balance_sheet': empty_df,
+                'cash_flow': empty_df,
+                'quarterly_income_stmt': empty_df,
+                'quarterly_balance_sheet': empty_df,
+                'quarterly_cash_flow': empty_df
+            }
+
+    def get_free_cash_flow(self, ticker):
+        """Get the most recent free cash flow value"""
+        try:
+            # First try to get FCF directly from info
+            metrics = self.get_key_metrics(ticker)
+            if metrics.get('Free Cash Flow', 'N/A') != 'N/A':
+                fcf = metrics.get('Free Cash Flow')
+                # Handle negative FCF by using 0 as the base
+                if fcf is not None and fcf < 0:
+                    print(f"Warning: Negative FCF ({fcf}) for {ticker}, using 0 as base for DCF")
+                    return 0
+                return fcf
+
+            # If not available, calculate from cash flow statement
+            financial_statements = self.get_financial_statements(ticker)
+            cash_flow = financial_statements['cash_flow']
+
+            if cash_flow.empty:
+                return None
+
+            # Check if 'Free Cash Flow' is directly available
+            if 'Free Cash Flow' in cash_flow.index:
+                fcf = cash_flow.loc['Free Cash Flow', cash_flow.columns[0]]
+                # Handle negative FCF by using 0 as the base
+                if fcf is not None and fcf < 0:
+                    print(f"Warning: Negative FCF ({fcf}) for {ticker}, using 0 as base for DCF")
+                    return 0
+                return fcf
+
+            # If not, try to calculate it from components
+            if 'Operating Cash Flow' in cash_flow.index and 'Capital Expenditure' in cash_flow.index:
+                operating_cf = cash_flow.loc['Operating Cash Flow', cash_flow.columns[0]]
+                capex = cash_flow.loc['Capital Expenditure', cash_flow.columns[0]]
+
+                if pd.notnull(operating_cf) and pd.notnull(capex):
+                    fcf = operating_cf + capex  # Note: capex is usually negative
+                    # Handle negative FCF by using 0 as the base
+                    if fcf is not None and fcf < 0:
+                        print(f"Warning: Negative FCF ({fcf}) for {ticker}, using 0 as base for DCF")
+                        return 0
+                    return fcf
+
+            return None
+        except Exception as e:
+            print(f"Error calculating free cash flow for {ticker}: {str(e)}")
+            return None

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=3.50.2
+yfinance>=0.2.28
+pandas>=2.0.0
+numpy>=1.24.0
+matplotlib>=3.7.0

utils.py

@@ -0,0 +1,792 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from datetime import datetime
+import matplotlib.dates as mdates
+from matplotlib.patches import Circle, RegularPolygon
+from matplotlib.path import Path
+from matplotlib.projections.polar import PolarAxes
+from matplotlib.projections import register_projection
+from matplotlib.spines import Spine
+from matplotlib.transforms import Affine2D
+import locale
+import matplotlib.ticker as mtick
+
+# Set locale for number formatting
+try:
+    locale.setlocale(locale.LC_ALL, '')
+except:
+    pass  # Fallback if locale setting fails
+
+def format_number(number, precision=2, currency_symbol='$', format_type='auto'):
+    """
+    Format large numbers with K, M, B, T suffixes or with commas
+
+    Parameters:
+    - number: The number to format
+    - precision: Decimal precision
+    - currency_symbol: Currency symbol to use
+    - format_type: 'auto', 'suffix', 'comma', 'millions', 'billions'
+    """
+    if number is None or number == 'N/A':
+        return 'N/A'
+
+    try:
+        number = float(number)
+    except:
+        return str(number)
+
+    # Handle negative numbers
+    is_negative = number < 0
+    abs_number = abs(number)
+
+    # Format based on type
+    if format_type == 'comma':
+        # Format with commas
+        try:
+            formatted = locale.format_string(f"%.{precision}f", abs_number, grouping=True)
+        except:
+            # Fallback if locale formatting fails
+            formatted = f"{abs_number:,.{precision}f}"
+    elif format_type == 'millions':
+        # Always format in millions
+        formatted = f"{abs_number / 1_000_000:.{precision}f}M"
+    elif format_type == 'billions':
+        # Always format in billions
+        formatted = f"{abs_number / 1_000_000_000:.{precision}f}B"
+    else:  # 'auto' or 'suffix'
+        # Format with appropriate suffix based on magnitude
+        if abs_number >= 1_000_000_000_000:
+            formatted = f"{abs_number / 1_000_000_000_000:.{precision}f}T"
+        elif abs_number >= 1_000_000_000:
+            formatted = f"{abs_number / 1_000_000_000:.{precision}f}B"
+        elif abs_number >= 1_000_000:
+            formatted = f"{abs_number / 1_000_000:.{precision}f}M"
+        elif abs_number >= 1_000:
+            formatted = f"{abs_number / 1_000:.{precision}f}K"
+        else:
+            formatted = f"{abs_number:.{precision}f}"
+
+    # Add negative sign if needed
+    if is_negative:
+        return f"-{currency_symbol}{formatted}"
+    else:
+        return f"{currency_symbol}{formatted}"
+
+def format_percentage(number, precision=2):
+    """Format number as percentage"""
+    if number is None or number == 'N/A':
+        return 'N/A'
+
+    try:
+        number = float(number)
+        return f"{number:.{precision}f}%"
+    except:
+        return str(number)
+
+def create_price_chart(price_history):
+    """Create a price chart from historical data"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if price_history is None or len(price_history) == 0:
+        fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, "No price history data available", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    fig = plt.figure(figsize=(10, 6))
+
+    # Calculate moving averages if enough data points
+    if len(price_history) > 50:
+        ma50 = price_history.rolling(window=50).mean()
+        ma200 = price_history.rolling(window=min(200, len(price_history))).mean()
+
+        plt.plot(price_history.index, price_history.values, label='Price')
+        plt.plot(ma50.index, ma50.values, label='50-Day MA', linestyle='--')
+        plt.plot(ma200.index, ma200.values, label='200-Day MA', linestyle='-.')
+        plt.legend()
+    else:
+        plt.plot(price_history.index, price_history.values)
+
+    # Format x-axis to show dates nicely
+    plt.gca().xaxis.set_major_formatter(mdates.DateFormatter('%b %Y'))
+    plt.gca().xaxis.set_major_locator(mdates.MonthLocator(interval=2))
+    plt.gcf().autofmt_xdate()
+
+    # Add grid and labels
+    plt.title('Stock Price History', fontsize=14)
+    plt.xlabel('Date')
+    plt.ylabel('Price')
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+
+    return fig
+
+def format_metrics_table(metrics):
+    """Format metrics for display in a table"""
+    formatted_metrics = {}
+    currency_symbol = metrics.get('Currency Symbol', '$')
+
+    for key, value in metrics.items():
+        if key == 'Market Cap':
+            formatted_metrics[key] = format_number(value, currency_symbol=currency_symbol)
+        elif key in ['Dividend Yield (%)', 'Profit Margin', 'Operating Margin', 'ROE', 'ROA', 'Revenue Growth', 
+                    'Payout Ratio', 'Earnings Growth', 'EBITDA Margins', 'Gross Margins'] or key.endswith('(%)'):
+            formatted_metrics[key] = format_percentage(value)
+        elif key in ['Current Price', 'EPS', '52 Week High', '52 Week Low', '50-Day MA', '200-Day MA', 
+                    'Revenue Per Share', 'Target Mean Price', 'Free Cash Flow', 'Operating Cash Flow']:
+            if value != 'N/A':
+                formatted_metrics[key] = f"{currency_symbol}{value:.2f}"
+            else:
+                formatted_metrics[key] = value
+        elif key in ['P/E Ratio', 'P/B Ratio', 'Forward P/E', 'PEG Ratio', 'Debt to Equity', 
+                    'Current Ratio', 'Quick Ratio', 'Beta', 'EV/EBITDA', 'EV/Revenue']:
+            if value != 'N/A':
+                formatted_metrics[key] = f"{value:.2f}"
+            else:
+                formatted_metrics[key] = value
+        else:
+            formatted_metrics[key] = value
+
+    return formatted_metrics
+
+def format_financial_statement(statement, statement_type, currency_symbol='$', format_type='millions'):
+    """
+    Format financial statement for display
+
+    Parameters:
+    - statement: The financial statement DataFrame
+    - statement_type: Type of statement (for title)
+    - currency_symbol: Currency symbol to use
+    - format_type: How to format numbers ('comma', 'millions', 'billions', 'auto')
+    """
+    if statement is None or statement.empty:
+        return pd.DataFrame()
+
+    # Make a copy to avoid modifying the original
+    df = statement.copy()
+
+    # Format column names (dates)
+    df.columns = [col.strftime('%Y-%m-%d') if isinstance(col, datetime) else str(col) for col in df.columns]
+
+    # Format the values based on format_type
+    if format_type == 'comma':
+        # Format with commas
+        for col in df.columns:
+            df[col] = df[col].apply(lambda x: format_number(x, currency_symbol=currency_symbol, format_type='comma') if pd.notnull(x) else 'N/A')
+    elif format_type == 'millions':
+        # Convert to millions and format
+        df = df / 1_000_000
+        for col in df.columns:
+            df[col] = df[col].apply(lambda x: f"{currency_symbol}{x:.2f}M" if pd.notnull(x) else 'N/A')
+    elif format_type == 'billions':
+        # Convert to billions and format
+        df = df / 1_000_000_000
+        for col in df.columns:
+            df[col] = df[col].apply(lambda x: f"{currency_symbol}{x:.2f}B" if pd.notnull(x) else 'N/A')
+    else:  # 'auto'
+        # Determine appropriate scale based on data magnitude
+        max_abs_val = abs(df.max().max())
+        if max_abs_val >= 1_000_000_000:
+            df = df / 1_000_000_000
+            suffix = 'B'
+        else:
+            df = df / 1_000_000
+            suffix = 'M'
+
+        for col in df.columns:
+            df[col] = df[col].apply(lambda x: f"{currency_symbol}{x:.2f}{suffix}" if pd.notnull(x) else 'N/A')
+
+    return df
+
+def prepare_financial_table(statement, currency_symbol='$', format_type='millions'):
+    """
+    Prepare financial statement for display in a table format
+
+    Returns a dictionary with formatted data and metadata
+    """
+    if statement is None or statement.empty:
+        return {"error": "No data available"}
+
+    # Format the statement
+    formatted_df = format_financial_statement(statement, "", currency_symbol, format_type)
+
+    # Prepare data for display
+    result = {
+        "data": formatted_df.reset_index().to_dict('records'),
+        "columns": [{"name": "Metric", "id": "index"}] + [{"name": col, "id": col} for col in formatted_df.columns],
+        "format_type": format_type,
+        "currency_symbol": currency_symbol
+    }
+
+    return result
+
+def create_financial_chart(statement, title, chart_type='bar'):
+    """Create a chart from financial statement data"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if statement is None or statement.empty:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No data available", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Select key metrics based on statement type
+    if 'Total Revenue' in statement.index:  # Income Statement
+        metrics = ['Total Revenue', 'Gross Profit', 'Operating Income', 'Net Income']
+    elif 'Total Assets' in statement.index:  # Balance Sheet
+        metrics = ['Total Assets', 'Total Liabilities Net Minority Interest', 'Total Equity Gross Minority Interest']
+    elif 'Operating Cash Flow' in statement.index:  # Cash Flow
+        metrics = ['Operating Cash Flow', 'Free Cash Flow', 'Capital Expenditures']
+    else:
+        # Default to first 4 rows if specific metrics not found
+        metrics = statement.index[:4]
+
+    # Filter for selected metrics that exist in the statement
+    metrics = [m for m in metrics if m in statement.index]
+
+    if not metrics:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No relevant metrics found", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Get data for the selected metrics
+    data = statement.loc[metrics]
+
+    # Convert to millions for better readability
+    data = data / 1_000_000
+
+    # Create the chart
+    fig = plt.figure(figsize=(12, 6))
+
+    if chart_type == 'bar':
+        ax = data.T.plot(kind='bar', ax=plt.gca(), width=0.8)
+
+        # Add value labels on top of bars
+        for container in ax.containers:
+            ax.bar_label(container, fmt='%.1fM', fontsize=8)
+    else:  # line chart
+        ax = data.T.plot(kind='line', marker='o', ax=plt.gca())
+
+        # Add value labels at data points
+        for line, metric in zip(ax.get_lines(), metrics):
+            x_data, y_data = line.get_data()
+            for x, y in zip(x_data, y_data):
+                ax.annotate(f'{y:.1f}M', (x, y), textcoords="offset points", 
+                            xytext=(0,5), ha='center', fontsize=8)
+
+    plt.title(title, fontsize=14)
+    plt.ylabel('Millions ($)')
+    plt.grid(True, alpha=0.3)
+    plt.legend(loc='best')
+    plt.tight_layout()
+
+    return fig
+
+def create_key_metrics_chart(statement, title, metrics_list, currency_symbol='$'):
+    """Create a chart for specific key metrics from financial statements"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if statement is None or statement.empty:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No data available", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Filter for selected metrics that exist in the statement
+    available_metrics = [m for m in metrics_list if m in statement.index]
+
+    if not available_metrics:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No relevant metrics found", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Get data for the selected metrics
+    data = statement.loc[available_metrics]
+
+    # Convert to millions for better readability
+    data = data / 1_000_000
+
+    # Create the chart
+    fig = plt.figure(figsize=(12, 6))
+
+    # Create a bar chart
+    ax = data.T.plot(kind='bar', ax=plt.gca(), width=0.8)
+
+    # Add value labels on top of bars
+    for container in ax.containers:
+        ax.bar_label(container, fmt=f'%.1fM', fontsize=8)
+
+    plt.title(title, fontsize=14)
+    plt.ylabel(f'Millions ({currency_symbol})')
+    plt.grid(True, alpha=0.3)
+    plt.legend(loc='best')
+    plt.tight_layout()
+
+    return fig
+
+def create_growth_chart(statement, metric_name, title):
+    """Create a growth rate chart for a specific metric"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if statement is None or statement.empty or metric_name not in statement.index:
+        fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, f"No data available for {metric_name}", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Get data for the selected metric
+    data = statement.loc[metric_name]
+
+    # Calculate year-over-year growth rates
+    growth_rates = data.pct_change(-1) * 100  # Multiply by -1 to get YoY since columns are in reverse chronological order
+
+    # Create the chart
+    fig = plt.figure(figsize=(10, 6))
+
+    # Plot the growth rates
+    ax = plt.gca()
+    bars = ax.bar(growth_rates.index, growth_rates.values, color='teal', alpha=0.7)
+
+    # Add value labels on top of bars
+    for bar in bars:
+        height = bar.get_height()
+        if not np.isnan(height):
+            ax.text(bar.get_x() + bar.get_width()/2., height + (1 if height >= 0 else -5),
+                    f'{height:.1f}%', ha='center', va='bottom' if height >= 0 else 'top', fontsize=9)
+
+    # Format y-axis as percentage
+    ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+
+    # Add a horizontal line at y=0
+    plt.axhline(y=0, color='black', linestyle='-', alpha=0.3)
+
+    plt.title(title, fontsize=14)
+    plt.ylabel('Year-over-Year Growth (%)')
+    plt.grid(True, alpha=0.3)
+    plt.tight_layout()
+
+    return fig
+
+def create_margin_chart(statement, title):
+    """Create a chart showing margin trends"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    # Check if we have the necessary data
+    required_metrics = ['Total Revenue', 'Gross Profit', 'Operating Income', 'Net Income']
+    if statement is None or statement.empty or not all(metric in statement.index for metric in required_metrics):
+        fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, "Insufficient data for margin analysis", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Get data for the required metrics
+    revenue = statement.loc['Total Revenue']
+    gross_profit = statement.loc['Gross Profit']
+    operating_income = statement.loc['Operating Income']
+    net_income = statement.loc['Net Income']
+
+    # Calculate margins
+    gross_margin = (gross_profit / revenue) * 100
+    operating_margin = (operating_income / revenue) * 100
+    net_margin = (net_income / revenue) * 100
+
+    # Create DataFrame for plotting
+    margins_df = pd.DataFrame({
+        'Gross Margin': gross_margin,
+        'Operating Margin': operating_margin,
+        'Net Margin': net_margin
+    })
+
+    # Create the chart
+    fig = plt.figure(figsize=(10, 6))
+
+    # Plot margins
+    ax = margins_df.plot(kind='line', marker='o', ax=plt.gca())
+
+    # Format y-axis as percentage
+    ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+
+    # Add value labels at data points
+    for line, margin_type in zip(ax.get_lines(), margins_df.columns):
+        x_data, y_data = line.get_data()
+        for x, y in zip(x_data, y_data):
+            ax.annotate(f'{y:.1f}%', (x, y), textcoords="offset points", 
+                        xytext=(0,5), ha='center', fontsize=8)
+
+    plt.title(title, fontsize=14)
+    plt.ylabel('Margin (%)')
+    plt.grid(True, alpha=0.3)
+    plt.legend(loc='best')
+    plt.tight_layout()
+
+    return fig
+
+def radar_factory(num_vars, frame='circle'):
+    """Create a radar chart with `num_vars` axes."""
+    # Calculate evenly-spaced axis angles
+    theta = np.linspace(0, 2*np.pi, num_vars, endpoint=False)
+
+    class RadarAxes(PolarAxes):
+        name = 'radar'
+
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            # Rotate plot so that first axis is at the top
+            self.set_theta_zero_location('N')
+
+        def fill(self, *args, closed=True, **kwargs):
+            """Override fill so that line is closed by default"""
+            return super().fill(closed=closed, *args, **kwargs)
+
+        def plot(self, *args, **kwargs):
+            """Override plot so that line is closed by default"""
+            lines = super().plot(*args, **kwargs)
+            for line in lines:
+                self._close_line(line)
+            return lines
+
+        def _close_line(self, line):
+            x, y = line.get_data()
+            # FIXME: markers at x[0], y[0] get doubled-up
+            if x[0] != x[-1]:
+                x = np.append(x, x[0])
+                y = np.append(y, y[0])
+                line.set_data(x, y)
+
+        def set_varlabels(self, labels):
+            self.set_thetagrids(np.degrees(theta), labels)
+
+        def _gen_axes_patch(self):
+            # The Axes patch must be centered at (0.5, 0.5) and of radius 0.5
+            # in axes coordinates.
+            if frame == 'circle':
+                return Circle((0.5, 0.5), 0.5)
+            elif frame == 'polygon':
+                return RegularPolygon((0.5, 0.5), num_vars, radius=0.5, orientation=np.pi/2)
+            else:
+                raise ValueError("Unknown value for 'frame': %s" % frame)
+
+        def _gen_axes_spines(self):
+            if frame == 'circle':
+                return super()._gen_axes_spines()
+            elif frame == 'polygon':
+                # spine_type must be 'left'/'right'/'top'/'bottom'/'circle'.
+                spine = Spine(axes=self,
+                              spine_type='circle',
+                              path=Path.unit_regular_polygon(num_vars))
+                # unit_regular_polygon returns a polygon of radius 1 centered at
+                # (0, 0) but we want a polygon of radius 0.5 centered at (0.5,
+                # 0.5) in axes coordinates.
+                spine.set_transform(Affine2D().scale(.5).translate(.5, .5)
+                                    + self.transAxes)
+                return {'polar': spine}
+            else:
+                raise ValueError("Unknown value for 'frame': %s" % frame)
+
+    # Register the projection with Matplotlib
+    register_projection(RadarAxes)
+    return theta
+
+def create_spider_chart(metrics, title="Financial Metrics Comparison"):
+    """Create a spider/radar chart for key financial metrics"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    # Select metrics to display on the spider chart - expanded list
+    spider_metrics = {
+        'P/E Ratio': metrics.get('P/E Ratio', 'N/A'),
+        'P/B Ratio': metrics.get('P/B Ratio', 'N/A'),
+        'EV/EBITDA': metrics.get('EV/EBITDA', 'N/A'),
+        'PEG Ratio': metrics.get('PEG Ratio', 'N/A'),
+        'ROE (%)': metrics.get('ROE', 'N/A'),
+        'ROA (%)': metrics.get('ROA', 'N/A'),
+        'Profit Margin (%)': metrics.get('Profit Margin', 'N/A'),
+        'Operating Margin (%)': metrics.get('Operating Margin', 'N/A'),
+        'Debt to Equity': metrics.get('Debt to Equity', 'N/A'),
+        'Current Ratio': metrics.get('Current Ratio', 'N/A'),
+        'Dividend Yield (%)': metrics.get('Dividend Yield (%)', 'N/A'),
+        'Revenue Growth (%)': metrics.get('Revenue Growth', 'N/A')
+    }
+
+    # Filter out N/A values and prepare data
+    filtered_metrics = {k: v for k, v in spider_metrics.items() if v != 'N/A' and v is not None}
+
+    if len(filtered_metrics) < 3:
+        # Not enough metrics for a meaningful spider chart
+        fig = plt.figure(figsize=(10, 10))
+        plt.text(0.5, 0.5, "Insufficient data for spider chart", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Prepare data for radar chart
+    categories = list(filtered_metrics.keys())
+    N = len(categories)
+
+    # Create radar chart
+    theta = radar_factory(N, frame='polygon')
+
+    # Normalize values for better visualization
+    values = list(filtered_metrics.values())
+
+    # Define normalization parameters for each metric
+    normalization_params = {
+        'P/E Ratio': {'better': 'lower', 'max': 50, 'min': 0},
+        'P/B Ratio': {'better': 'lower', 'max': 10, 'min': 0},
+        'EV/EBITDA': {'better': 'lower', 'max': 20, 'min': 0},
+        'PEG Ratio': {'better': 'lower', 'max': 3, 'min': 0},
+        'ROE (%)': {'better': 'higher', 'max': 30, 'min': 0},
+        'ROA (%)': {'better': 'higher', 'max': 15, 'min': 0},
+        'Profit Margin (%)': {'better': 'higher', 'max': 30, 'min': 0},
+        'Operating Margin (%)': {'better': 'higher', 'max': 30, 'min': 0},
+        'Debt to Equity': {'better': 'lower', 'max': 3, 'min': 0},
+        'Current Ratio': {'better': 'higher', 'max': 3, 'min': 0},
+        'Dividend Yield (%)': {'better': 'higher', 'max': 10, 'min': 0},
+        'Revenue Growth (%)': {'better': 'higher', 'max': 30, 'min': 0}
+    }
+
+    # Normalize values
+    normalized = []
+    for i, (cat, val) in enumerate(zip(categories, values)):
+        params = normalization_params.get(cat, {'better': 'higher', 'max': 100, 'min': 0})
+
+        # Clip value to min/max range
+        val = max(min(val, params['max']), params['min'])
+
+        # Normalize to 0-1 scale
+        if params['better'] == 'lower':
+            # For metrics where lower is better, invert the scale
+            norm_val = 1 - ((val - params['min']) / (params['max'] - params['min']))
+        else:
+            # For metrics where higher is better
+            norm_val = (val - params['min']) / (params['max'] - params['min'])
+
+        normalized.append(norm_val)
+
+    # Create the figure
+    fig, ax = plt.subplots(figsize=(10, 10), subplot_kw=dict(projection='radar'))
+
+    # Plot the data
+    ax.plot(theta, normalized, 'o-', linewidth=2)
+    ax.fill(theta, normalized, alpha=0.25)
+
+    # Set labels
+    ax.set_varlabels(categories)
+
+    # Add values to the plot
+    for i, (angle, radius) in enumerate(zip(theta, normalized)):
+        ax.text(angle, radius + 0.1, f"{values[i]:.1f}", 
+                horizontalalignment='center', verticalalignment='center')
+
+    # Add title
+    plt.title(title, position=(0.5, 1.1), size=15)
+
+    # Add a reference circle at 0.5
+    ax.plot(theta, [0.5]*N, '--', color='gray', alpha=0.75, linewidth=1)
+
+    return fig
+
+def create_multi_year_growth_chart(statement, metrics, title, currency_symbol='$'):
+    """Create a chart showing growth of multiple metrics over years"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if statement is None or statement.empty:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No data available", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Filter for metrics that exist in the statement
+    available_metrics = [m for m in metrics if m in statement.index]
+
+    if not available_metrics:
+        fig = plt.figure(figsize=(12, 6))
+        plt.text(0.5, 0.5, "No relevant metrics found", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Get data for the selected metrics
+    data = statement.loc[available_metrics]
+
+    # Convert to billions for better readability
+    data = data / 1_000_000_000
+
+    # Create the chart
+    fig = plt.figure(figsize=(12, 6))
+
+    # Plot as line chart
+    ax = data.T.plot(kind='line', marker='o', ax=plt.gca())
+
+    # Add value labels at data points
+    for line, metric in zip(ax.get_lines(), available_metrics):
+        x_data, y_data = line.get_data()
+        for x, y in zip(x_data, y_data):
+            ax.annotate(f'{y:.1f}B', (x, y), textcoords="offset points", 
+                        xytext=(0,5), ha='center', fontsize=8)
+
+    plt.title(title, fontsize=14)
+    plt.ylabel(f'Billions ({currency_symbol})')
+    plt.grid(True, alpha=0.3)
+    plt.legend(loc='best')
+    plt.tight_layout()
+
+    return fig
+
+def create_ratio_chart(statement, title, ratio_type='profitability'):
+    """Create a chart showing financial ratios over time"""
+    # Close any existing figures to prevent memory issues
+    plt.close('all')
+
+    if statement is None or statement.empty:
+        fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, "No data available", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Define metrics based on ratio type
+    if ratio_type == 'profitability':
+        if 'Total Revenue' in statement.index and 'Net Income' in statement.index:
+            revenue = statement.loc['Total Revenue']
+            net_income = statement.loc['Net Income']
+            net_margin = (net_income / revenue) * 100
+
+            if 'Gross Profit' in statement.index and 'Operating Income' in statement.index:
+                gross_profit = statement.loc['Gross Profit']
+                operating_income = statement.loc['Operating Income']
+
+                gross_margin = (gross_profit / revenue) * 100
+                operating_margin = (operating_income / revenue) * 100
+
+                # Create DataFrame for plotting
+                ratios_df = pd.DataFrame({
+                    'Gross Margin': gross_margin,
+                    'Operating Margin': operating_margin,
+                    'Net Margin': net_margin
+                })
+            else:
+                # Only net margin available
+                ratios_df = pd.DataFrame({
+                    'Net Margin': net_margin
+                })
+        else:
+            fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, "Insufficient data for profitability ratios", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=14)
+            plt.axis('off')
+            return fig
+
+    elif ratio_type == 'efficiency':
+        if 'Total Assets' in statement.index and 'Net Income' in statement.index:
+            assets = statement.loc['Total Assets']
+            net_income = statement.loc['Net Income']
+            roa = (net_income / assets) * 100
+
+            if 'Total Equity Gross Minority Interest' in statement.index:
+                equity = statement.loc['Total Equity Gross Minority Interest']
+                roe = (net_income / equity) * 100
+
+                # Create DataFrame for plotting
+                ratios_df = pd.DataFrame({
+                    'Return on Assets': roa,
+                    'Return on Equity': roe
+                })
+            else:
+                # Only ROA available
+                ratios_df = pd.DataFrame({
+                    'Return on Assets': roa
+                })
+        else:
+            fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, "Insufficient data for efficiency ratios", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=14)
+            plt.axis('off')
+            return fig
+
+    elif ratio_type == 'liquidity':
+        if 'Current Assets' in statement.index and 'Current Liabilities' in statement.index:
+            current_assets = statement.loc['Current Assets']
+            current_liabilities = statement.loc['Current Liabilities']
+            current_ratio = current_assets / current_liabilities
+
+            if 'Inventory' in statement.index:
+                inventory = statement.loc['Inventory']
+                quick_ratio = (current_assets - inventory) / current_liabilities
+
+                # Create DataFrame for plotting
+                ratios_df = pd.DataFrame({
+                    'Current Ratio': current_ratio,
+                    'Quick Ratio': quick_ratio
+                })
+            else:
+                # Only current ratio available
+                ratios_df = pd.DataFrame({
+                    'Current Ratio': current_ratio
+                })
+        else:
+            fig = plt.figure(figsize=(10, 6))
+            plt.text(0.5, 0.5, "Insufficient data for liquidity ratios", 
+                     horizontalalignment='center', verticalalignment='center', fontsize=14)
+            plt.axis('off')
+            return fig
+
+    else:  # Default case
+        fig = plt.figure(figsize=(10, 6))
+        plt.text(0.5, 0.5, f"Unknown ratio type: {ratio_type}", 
+                 horizontalalignment='center', verticalalignment='center', fontsize=14)
+        plt.axis('off')
+        return fig
+
+    # Create the chart
+    fig = plt.figure(figsize=(10, 6))
+
+    # Plot ratios
+    ax = ratios_df.plot(kind='line', marker='o', ax=plt.gca())
+
+    # Format y-axis as percentage for profitability and efficiency ratios
+    if ratio_type in ['profitability', 'efficiency']:
+        ax.yaxis.set_major_formatter(mtick.PercentFormatter())
+
+    # Add value labels at data points
+    for line, ratio_name in zip(ax.get_lines(), ratios_df.columns):
+        x_data, y_data = line.get_data()
+        for x, y in zip(x_data, y_data):
+            if ratio_type in ['profitability', 'efficiency']:
+                label = f'{y:.1f}%'
+            else:
+                label = f'{y:.2f}'
+            ax.annotate(label, (x, y), textcoords="offset points", 
+                        xytext=(0,5), ha='center', fontsize=8)
+
+    plt.title(title, fontsize=14)
+
+    if ratio_type == 'profitability':
+        plt.ylabel('Margin (%)')
+    elif ratio_type == 'efficiency':
+        plt.ylabel('Return (%)')
+    elif ratio_type == 'liquidity':
+        plt.ylabel('Ratio')
+
+    plt.grid(True, alpha=0.3)
+    plt.legend(loc='best')
+    plt.tight_layout()
+
+    return fig

valuation.py

@@ -0,0 +1,88 @@
+class DCFValuation:
+    def __init__(self):
+        pass
+
+    def calculate_dcf(self, fcf, growth_rate, discount_rate, years):
+        """
+        Calculate the Discounted Cash Flow (DCF) valuation
+
+        Parameters:
+        - fcf: Free Cash Flow (most recent year)
+        - growth_rate: Expected annual growth rate (decimal)
+        - discount_rate: Discount rate (decimal)
+        - years: Number of years to project
+
+        Returns:
+        - Present value of future cash flows plus terminal value
+        """
+        if fcf is None:
+            raise ValueError("Free Cash Flow data is not available")
+
+        if fcf <= 0:
+            # For companies with negative or zero FCF, we'll use a small positive value
+            # This is a simplification - in reality, you might want to use other valuation methods
+            fcf = 1000000  # Use a nominal value of $1M
+            print(f"Warning: Using nominal FCF value of $1M for DCF calculation due to non-positive actual FCF")
+
+        if growth_rate < 0 or growth_rate > 2.5:
+            raise ValueError("Growth rate should be between 0 and 2.5 (0% to 250%)")
+
+        if discount_rate <= 0 or discount_rate > 0.3:
+            raise ValueError("Discount rate should be between 0 and 0.3 (0% to 30%)")
+
+        if years <= 0:
+            raise ValueError("Projection years must be positive")
+
+        # Calculate present value of projected cash flows
+        pv_fcf = 0
+        for year in range(1, years + 1):
+            projected_fcf = fcf * (1 + growth_rate) ** year
+            pv_fcf += projected_fcf / (1 + discount_rate) ** year
+
+        # Calculate terminal value (Gordon Growth Model)
+        # Assume long-term growth rate is lower than initial growth rate
+        # For high growth companies, cap the terminal growth rate at a reasonable level
+        terminal_growth_rate = min(growth_rate, 0.04)  # Cap at 4% for sustainability
+
+        # For very high growth rates, use a more aggressive reduction to terminal rate
+        if growth_rate > 0.5:
+            # For high growth companies, use a more gradual approach to terminal value
+            # This simulates a company with high initial growth that normalizes over time
+            terminal_value = 0
+            transition_years = min(5, years)  # Use up to 5 transition years
+
+            # Last projected FCF
+            last_fcf = fcf * (1 + growth_rate) ** years
+
+            # Calculate terminal value with gradual growth reduction
+            terminal_value = last_fcf * (1 + terminal_growth_rate) / (discount_rate - terminal_growth_rate)
+        else:
+            # Standard terminal value calculation
+            terminal_value = fcf * (1 + growth_rate) ** years * (1 + terminal_growth_rate) / (discount_rate - terminal_growth_rate)
+
+        # Discount terminal value to present
+        pv_terminal_value = terminal_value / (1 + discount_rate) ** years
+
+        # Total company value
+        company_value = pv_fcf + pv_terminal_value
+
+        return company_value
+
+    def calculate_per_share_value(self, company_value, shares_outstanding):
+        """
+        Calculate per share value
+
+        Parameters:
+        - company_value: Total company value from DCF
+        - shares_outstanding: Number of shares outstanding
+
+        Returns:
+        - Value per share
+        """
+        if shares_outstanding is None or shares_outstanding == 'N/A':
+            raise ValueError("Shares outstanding data is not available")
+
+        if shares_outstanding <= 0:
+            raise ValueError("Shares outstanding must be positive")
+
+        return company_value / shares_outstanding