Experimenting Stock Valuation using Gradio and Yfinance libraries

Introduction

In the world of financial analysis, Discounted Cash Flow (DCF) valuation stands as one of the most fundamental approaches to determining a company's intrinsic value. While professional analysts often use complex spreadsheets or expensive software for this purpose, I set out to create an accessible, interactive, and comprehensive tool that democratizes financial analysis for individual investors.

This article details the development of a Stock DCF Valuation Tool that combines financial data retrieval, DCF modeling, and interactive visualizations in a user-friendly web application. The project leverages Python's data science ecosystem along with Gradio to create an intuitive interface for analyzing publicly traded companies.

The Challenge of Financial Analysis

Individual investors face several challenges when attempting to value companies:

1. Data accessibility: Financial statements are scattered across various sources
2. Calculation complexity: DCF models require multiple steps and assumptions
3. Visualization limitations: Creating insightful charts from financial data is time-consuming
4. International coverage: Many tools focus only on US markets

Our goal was to address these challenges by creating a single application that could:

• Retrieve comprehensive financial data for any publicly traded company
• Perform DCF calculations with customizable parameters
• Generate insightful visualizations of financial metrics
• Support international markets, including Indian stocks

Technical Architecture

The application follows a modular design with four main components:

1. Data Retrieval: Fetches financial data from Yahoo Finance
2. Valuation Logic: Implements the DCF calculation methodology
3. Visualization Utilities: Creates charts and formats financial data
4. User Interface: Provides an interactive web interface using Gradio

Data Retrieval with yfinance

The data_fetcher.py module handles all data retrieval operations using the yfinance library. It includes methods for fetching:

• Historical price data
• Key financial metrics
• Annual and quarterly financial statements
• Free cash flow data

A key challenge was handling the inconsistencies in financial data across different companies and markets. The solution implements robust error handling and data validation.

Here's a simplified example of the free cash flow retrieval function:

def get_free_cash_flow(self, ticker):
    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:
                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]]
            if fcf is not None and fcf < 0:
                return 0
            return fcf

        # Calculate it from components if needed
        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
                if fcf < 0:
                    return 0
                return fcf

        return None
    except Exception as e:
        return None

DCF Valuation Methodology

The valuation.py module implements a two-stage DCF model:

1. Growth Stage: Projects cash flows for a specified number of years using a user-defined growth rate
2. Terminal Stage: Calculates a terminal value using a sustainable long-term growth rate

The implementation handles various edge cases, including high-growth scenarios and negative cash flows:

def calculate_dcf(self, fcf, growth_rate, discount_rate, years):
    if fcf is None:
        raise ValueError("Free Cash Flow data is not available")

    if fcf <= 0:
        # For companies with negative or zero FCF, use a nominal value
        fcf = 1000000  # Use a nominal value of $1M

    # 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

    # For high growth rates, use a more sophisticated terminal value calculation
    terminal_growth_rate = min(growth_rate, 0.04)  # Cap at 4% for sustainability

    if growth_rate > 0.5:  # For growth rates > 50%
        # Use a gradual approach to terminal value
        last_fcf = fcf * (1 + growth_rate) ** years
        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

Visualization Capabilities

The utils.py module provides extensive visualization functions, including:

• Price charts with moving averages
• Financial statement bar charts
• Spider/radar charts for comparing financial metrics
• Growth and margin analysis charts
• Ratio charts for profitability and efficiency

One of the most insightful visualizations is the spider chart, which normalizes and displays multiple financial metrics in a single view:

def create_spider_chart(metrics, title="Financial Metrics Comparison"):
    # Select metrics to display on the spider chart
    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}

    # Create radar chart with normalization for better visualization
    # ... (radar chart implementation)

    return fig

User Interface with Gradio

The application uses Gradio to create an intuitive web interface with multiple tabs for different types of analysis:

with gr.Blocks(title="Stock DCF Valuation Tool") as app:
    gr.Markdown("# Stock DCF Valuation Tool")

    with gr.Row():
        with gr.Column(scale=1):
            ticker_input = gr.Textbox(label="Stock Ticker (e.g., AAPL, RELIANCE.NS)")
            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")
            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")

                # Additional tabs for financial statements and analysis
                # ...

Overcoming Technical Challenges

1. Handling Missing or Inconsistent Data

Financial data from public sources often contains gaps or inconsistencies. The application implements multiple fallback mechanisms:

• Trying alternative data sources when primary sources fail
• Using shorter time periods when full history isn't available
• Providing informative error messages when data is unavailable

2. Supporting International Stocks

Many financial tools struggle with international stocks, particularly those from emerging markets. Our solution:

• Detects stock exchange suffixes (.NS for NSE, .BO for BSE)
• Applies appropriate currency symbols (₹ for Indian stocks)
• Handles different reporting standards and data availability

3. Memory Management with Matplotlib

A significant challenge was managing memory when creating multiple visualizations:

# Close any existing matplotlib figures to prevent memory issues
plt.close('all')

# Register cleanup function when app closes
def on_close():
    plt.close('all')

app.load(on_close)

4. Handling High Growth Scenarios

Traditional DCF models struggle with high-growth companies. Our solution implements a more sophisticated approach for growth rates above 50%, using a gradual transition to sustainable growth rates.

Results and Impact

The final application provides a comprehensive financial analysis tool that:

1. Simplifies complex analysis: Users can perform DCF valuations with just a few clicks
2. Visualizes financial health: Interactive charts provide insights into company performance
3. Supports global markets: Works with US, Indian, and other international stocks
4. Handles edge cases: Provides meaningful results even with incomplete data

The tool is particularly valuable for:

• Individual investors performing fundamental analysis
• Finance students learning valuation techniques
• Financial educators demonstrating DCF concepts
• Analysts needing quick preliminary valuations

Live Demo and Code

You can try the live application at https://huggingface.co/spaces/vikramlingam/DCF-app

The complete source code is available on GitHub: https://github.com/vikramlingam/DCF_App

Future Enhancements

While the current version provides comprehensive functionality, several enhancements are planned:

1. Sensitivity Analysis: Visualize how changes in growth and discount rates affect valuation
2. Peer Comparison: Compare financial metrics across companies in the same sector
3. Export Functionality: Allow users to download reports and data
4. Alternative Valuation Methods: Add relative valuation models (P/E, EV/EBITDA)
5. Historical Valuation: Show how DCF valuation would have performed in the past

Conclusion

Building a comprehensive stock valuation tool demonstrates how modern Python libraries can be combined to create powerful financial analysis applications. By leveraging yfinance for data retrieval, matplotlib for visualization, and Gradio for the user interface, we've created an accessible tool that democratizes financial analysis.

The modular architecture ensures that the application can be easily extended with new features or deployed in different environments. Whether used by individual investors, students, or financial professionals, the Stock DCF Valuation Tool provides valuable insights into company valuation and financial health.

This project showcases the power of open-source tools in creating sophisticated financial applications that were once the exclusive domain of expensive professional software.