Create app.py

app.py

@@ -0,0 +1,716 @@
+import streamlit as st
+import requests
+import pandas as pd
+import plotly.graph_objs as go
+from plotly.subplots import make_subplots
+import os
+
+# ---------------------------
+# Global API Configuration (hidden)
+# ---------------------------
+API_KEY = os.getenv("FMP_API_KEY")
+BASE_URL = "https://financialmodelingprep.com/api/v3/"
+
+# ---------------------------
+# Data Fetching Functions
+# ---------------------------
+def fetch_fmp_data(endpoint, ticker, period="annual", limit=10):
+    url = f"{BASE_URL}{endpoint}/{ticker}"
+    params = {"period": period, "limit": limit, "apikey": API_KEY}
+    r = requests.get(url, params=params)
+    if r.status_code == 200:
+        return pd.DataFrame(r.json())
+    else:
+        st.error("Data retrieval error. Check inputs or try again later.")
+        return pd.DataFrame()
+
+def process_statement_df(df, date_col="date"):
+    if df.empty:
+        return df
+    df[date_col] = pd.to_datetime(df[date_col])
+    df.set_index(date_col, inplace=True)
+    return df.transpose()
+
+def fetch_historical_prices(ticker):
+    url = f"{BASE_URL}historical-price-full/{ticker}"
+    params = {"serietype": "line", "apikey": API_KEY}
+    r = requests.get(url, params=params)
+    if r.status_code == 200:
+        data = r.json()
+        if "historical" in data:
+            hist_df = pd.DataFrame(data["historical"])
+            hist_df["date"] = pd.to_datetime(hist_df["date"])
+            hist_df.sort_values("date", inplace=True)
+            return hist_df
+    st.error("Unable to fetch historical prices. Try again later.")
+    return pd.DataFrame()
+
+def get_closing_price_on_or_before(hist_df, date):
+    df = hist_df[hist_df["date"] <= date]
+    if not df.empty:
+        return df.iloc[-1]["close"]
+    return None
+
+def fetch_all_data(ticker="AAPL", period="annual", limit=10):
+    inc = fetch_fmp_data("income-statement", ticker, period, limit)
+    bs = fetch_fmp_data("balance-sheet-statement", ticker, period, limit)
+    cf = fetch_fmp_data("cash-flow-statement", ticker, period, limit)
+
+    income_statement = process_statement_df(inc)
+    balance_sheet = process_statement_df(bs)
+    cash_flow = process_statement_df(cf)
+    hist = fetch_historical_prices(ticker)
+
+    dates = set(income_statement.columns) | set(balance_sheet.columns) | set(cash_flow.columns)
+    end_prices = {}
+    for d in dates:
+        try:
+            dt = pd.to_datetime(d)
+        except Exception:
+            continue
+        price = get_closing_price_on_or_before(hist, dt)
+        end_prices[d] = price
+
+    return {
+        "income_statement": income_statement,
+        "balance_sheet": balance_sheet,
+        "cash_flow": cash_flow,
+        "end_prices": end_prices
+    }
+
+# ---------------------------
+# Analysis Functions
+# ---------------------------
+def extract_financial_data_for_column(income_statement, balance_sheet, col_label):
+    labels = {
+        "Net Income": ["netIncome"],
+        "EBT": ["incomeBeforeTax"],
+        "EBIT": ["operatingIncome"],
+        "Revenue": ["revenue"],
+        "Total Assets": ["totalAssets"],
+        "Total Equity": ["totalStockholdersEquity", "totalEquity"]
+    }
+    data = {}
+    for key, keys_list in labels.items():
+        value = None
+        if key in ["Net Income", "EBT", "EBIT", "Revenue"]:
+            for k in keys_list:
+                if k in income_statement.index and col_label in income_statement.columns:
+                    value = income_statement.loc[k, col_label]
+                    break
+        else:
+            for k in keys_list:
+                if k in balance_sheet.index and col_label in balance_sheet.columns:
+                    value = balance_sheet.loc[k, col_label]
+                    break
+        data[key] = value
+    return data
+
+def compute_advanced_dupont_roe(fin_data):
+    net_income = fin_data.get("Net Income")
+    ebt = fin_data.get("EBT")
+    ebit = fin_data.get("EBIT")
+    revenue = fin_data.get("Revenue")
+    total_assets = fin_data.get("Total Assets")
+    total_equity = fin_data.get("Total Equity")
+    
+    def safe_div(n, d):
+        return n / d if d and d != 0 else None
+
+    tax_burden = safe_div(net_income, ebt)
+    interest_burden = safe_div(ebt, ebit)
+    op_margin = safe_div(ebit, revenue)
+    asset_turnover = safe_div(revenue, total_assets)
+    equity_multiplier = safe_div(total_assets, total_equity)
+
+    if None in (tax_burden, interest_burden, op_margin, asset_turnover, equity_multiplier):
+        dupont_roe = None
+    else:
+        dupont_roe = tax_burden * interest_burden * op_margin * asset_turnover * equity_multiplier
+
+    return {
+        "Tax Burden": tax_burden,
+        "Interest Burden": interest_burden,
+        "Operating Margin": op_margin,
+        "Asset Turnover": asset_turnover,
+        "Equity Multiplier": equity_multiplier,
+        "Advanced DuPont ROE": dupont_roe
+    }
+
+def dupont_analysis_over_time(income_statement, balance_sheet):
+    results = {}
+    for col in income_statement.columns:
+        fin_data = extract_financial_data_for_column(income_statement, balance_sheet, col)
+        results[col] = compute_advanced_dupont_roe(fin_data)
+    return pd.DataFrame(results)
+
+def compute_equity_multiplier_details(balance_sheet):
+    asset_keys = ["totalAssets"]
+    equity_keys = ["totalStockholdersEquity", "totalEquity"]
+    liability_keys = ["totalLiabilities"]
+
+    def find_label(keys_list, df):
+        for k in keys_list:
+            if k in df.index:
+                return k
+        return None
+
+    asset_row = find_label(asset_keys, balance_sheet)
+    equity_row = find_label(equity_keys, balance_sheet)
+    liability_row = find_label(liability_keys, balance_sheet)
+
+    cols = balance_sheet.columns.tolist()
+    results = {
+        "Fiscal Year": [],
+        "Total Assets": [],
+        "Total Equity": [],
+        "Total Liabilities": [],
+        "Equity Multiplier": [],
+        "Debt to Equity": [],
+        "Assets YoY Change": [],
+        "Equity YoY Change": [],
+        "EM YoY Change": [],
+        "Debt/Equity YoY Change": []
+    }
+
+    prev_assets = prev_equity = prev_em = prev_de = None
+
+    def yoy_change(curr, prev):
+        if prev is None or pd.isna(curr) or pd.isna(prev) or prev == 0:
+            return None
+        return (curr - prev) / abs(prev)
+
+    for col in cols:
+        assets = balance_sheet.loc[asset_row, col] if asset_row and col in balance_sheet.columns else None
+        equity = balance_sheet.loc[equity_row, col] if equity_row and col in balance_sheet.columns else None
+        if liability_row and col in balance_sheet.columns:
+            liabilities = balance_sheet.loc[liability_row, col]
+        elif assets and equity:
+            liabilities = assets - equity
+        else:
+            liabilities = None
+
+        em = assets / equity if equity and equity != 0 else None
+        de = liabilities / equity if equity and equity != 0 else None
+
+        results["Fiscal Year"].append(col)
+        results["Total Assets"].append(assets)
+        results["Total Equity"].append(equity)
+        results["Total Liabilities"].append(liabilities)
+        results["Equity Multiplier"].append(em)
+        results["Debt to Equity"].append(de)
+
+        results["Assets YoY Change"].append(yoy_change(assets, prev_assets))
+        results["Equity YoY Change"].append(yoy_change(equity, prev_equity))
+        results["EM YoY Change"].append(yoy_change(em, prev_em))
+        results["Debt/Equity YoY Change"].append(yoy_change(de, prev_de))
+
+        prev_assets, prev_equity, prev_em, prev_de = assets, equity, em, de
+
+    return pd.DataFrame(results)
+
+def compute_additional_metrics(income_statement, em_df):
+    df = em_df.copy()
+    df["Net Income"] = None
+    df["Interest Coverage Ratio"] = None
+    df["ROE"] = None
+
+    for idx, row in df.iterrows():
+        fy = row["Fiscal Year"]
+        net_income = None
+        if "netIncome" in income_statement.index and fy in income_statement.columns:
+            net_income = income_statement.loc["netIncome", fy]
+
+        ebit = None
+        if "operatingIncome" in income_statement.index and fy in income_statement.columns:
+            ebit = income_statement.loc["operatingIncome", fy]
+
+        interest_exp = None
+        if "interestExpense" in income_statement.index and fy in income_statement.columns:
+            interest_exp = income_statement.loc["interestExpense", fy]
+
+        icr = None
+        if ebit and interest_exp and interest_exp != 0:
+            icr = ebit / interest_exp
+
+        roe = None
+        if net_income and row["Total Equity"] and row["Total Equity"] != 0:
+            roe = net_income / row["Total Equity"]
+
+        df.at[idx, "Net Income"] = net_income
+        df.at[idx, "Interest Coverage Ratio"] = icr
+        df.at[idx, "ROE"] = roe
+
+    return df
+
+def add_cash_flow_info(cash_flow_df, ext_df):
+    df = ext_df.copy()
+    df["Operating Cash Flow"] = None
+    df["CapEx"] = None
+
+    ocf_key = None
+    for key in ["totalCashFromOperatingActivities", "operatingCashFlow", "cashFlowFromOperatingActivities"]:
+        if key in cash_flow_df.index:
+            ocf_key = key
+            break
+
+    capex_key = None
+    for key in ["capitalExpenditure", "capitalExpenditures", "capex", "investingCapEx"]:
+        if key in cash_flow_df.index:
+            capex_key = key
+            break
+
+    for idx, row in df.iterrows():
+        fy = row["Fiscal Year"]
+
+        ocf = None
+        if ocf_key and fy in cash_flow_df.columns:
+            ocf = cash_flow_df.loc[ocf_key, fy]
+
+        capex = None
+        if capex_key and fy in cash_flow_df.columns:
+            capex = cash_flow_df.loc[capex_key, fy]
+
+        df.at[idx, "Operating Cash Flow"] = ocf
+        df.at[idx, "CapEx"] = capex
+
+    return df
+
+# ---------------------------
+# Plotting Functions
+# ---------------------------
+def plot_dupont_results(dupont_df):
+    df = dupont_df.transpose()
+    df.index = pd.to_datetime(df.index)
+    df.sort_index(inplace=True)
+    dates = df.index.strftime('%Y-%m-%d')
+    components = ["Tax Burden", "Interest Burden", "Operating Margin", "Asset Turnover", "Equity Multiplier"]
+    
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    for comp in components:
+        fig.add_trace(go.Bar(x=dates, y=df[comp], name=comp), secondary_y=False)
+
+    fig.add_trace(
+        go.Scatter(
+            x=dates,
+            y=df["Advanced DuPont ROE"],
+            mode="lines+markers",
+            name="Advanced DuPont ROE"
+        ),
+        secondary_y=True
+    )
+    fig.update_layout(
+        title="DuPont Components Over Time",
+        xaxis_title="Fiscal Period",
+        barmode="group"
+    )
+    fig.update_yaxes(title_text="Advanced DuPont ROE", secondary_y=True)
+    st.plotly_chart(fig, use_container_width=True)
+
+def plot_leverage_metrics_plotly(em_df, end_prices):
+    em_df["Date"] = pd.to_datetime(em_df["Fiscal Year"])
+    em_df.sort_values("Date", inplace=True)
+    dates = em_df["Date"].dt.strftime('%Y-%m-%d')
+
+    trace_assets = go.Scatter(x=dates, y=em_df["Total Assets"], mode='lines+markers', name="Total Assets")
+    trace_equity = go.Scatter(x=dates, y=em_df["Total Equity"], mode='lines+markers', name="Total Equity")
+    trace_em = go.Scatter(x=dates, y=em_df["Equity Multiplier"], mode='lines+markers', name="Equity Multiplier", yaxis="y2")
+    trace_de = go.Scatter(x=dates, y=em_df["Debt to Equity"], mode='lines+markers', name="Debt to Equity", yaxis="y2")
+
+    stock_prices = [end_prices.get(fy, None) for fy in em_df["Fiscal Year"]]
+    trace_sp = go.Scatter(x=dates, y=stock_prices, mode='lines+markers', name="Stock Price", yaxis="y3")
+
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    fig.add_trace(trace_assets)
+    fig.add_trace(trace_equity)
+    fig.add_trace(trace_em, secondary_y=True)
+    fig.add_trace(trace_de, secondary_y=True)
+    fig.add_trace(trace_sp)
+
+    fig.update_layout(
+        title="Leverage & Stock Price",
+        xaxis_title="Fiscal Year"
+    )
+    fig.update_yaxes(title_text="Assets & Equity", secondary_y=False)
+    fig.update_yaxes(title_text="Leverage Ratios", secondary_y=True)
+    fig.update_layout(
+        yaxis3=dict(
+            title="Stock Price (USD)",
+            overlaying="y",
+            side="right",
+            position=0.95
+        )
+    )
+    fig.data[-1].update(yaxis="y3")
+    st.plotly_chart(fig, use_container_width=True)
+
+def plot_combined_metrics_plotly(ext_df, end_prices):
+    ext_df["Date"] = pd.to_datetime(ext_df["Fiscal Year"])
+    ext_df.sort_values("Date", inplace=True)
+    dates = ext_df["Date"].dt.strftime('%Y-%m-%d')
+
+    trace_net = go.Bar(x=dates, y=ext_df["Net Income"], name="Net Income")
+    trace_ocf = go.Bar(x=dates, y=ext_df["Operating Cash Flow"], name="Op. Cash Flow")
+    trace_capex = go.Bar(x=dates, y=ext_df["CapEx"], name="CapEx")
+
+    trace_roe = go.Scatter(x=dates, y=ext_df["ROE"], mode='lines+markers', name="ROE", yaxis="y2")
+    trace_icr = go.Scatter(x=dates, y=ext_df["Interest Coverage Ratio"], mode='lines+markers', name="ICR", yaxis="y2")
+
+    stock_prices = [end_prices.get(fy, None) for fy in ext_df["Fiscal Year"]]
+    trace_sp = go.Scatter(x=dates, y=stock_prices, mode='lines+markers', name="Stock Price", yaxis="y3")
+
+    fig = make_subplots(specs=[[{"secondary_y": True}]])
+    fig.add_trace(trace_net, secondary_y=False)
+    fig.add_trace(trace_ocf, secondary_y=False)
+    fig.add_trace(trace_capex, secondary_y=False)
+    fig.add_trace(trace_roe, secondary_y=True)
+    fig.add_trace(trace_icr, secondary_y=True)
+    fig.add_trace(trace_sp)
+
+    fig.update_layout(
+        title="Net Income, Cash Flow & ROE",
+        xaxis_title="Fiscal Year",
+        barmode="group"
+    )
+    fig.update_yaxes(title_text="Values (USD)", secondary_y=False)
+    fig.update_yaxes(title_text="Ratios", secondary_y=True)
+    fig.update_layout(
+        yaxis3=dict(
+            title="Stock Price (USD)",
+            overlaying="y",
+            side="right",
+            position=0.95
+        )
+    )
+    fig.data[-1].update(yaxis="y3")
+    st.plotly_chart(fig, use_container_width=True)
+
+# ---------------------------
+# Streamlit App Layout & Sidebar
+# ---------------------------
+st.set_page_config(layout="wide", page_title="ROE Decomposition Dashboard")
+
+st.title("ROE Decomposition")
+st.markdown("""
+This application deconstructs return on equity using an advanced DuPont analysis approach.
+It examines how profitability, leverage, and operational efficiency contribute to ROE over time.
+""")
+
+with st.expander("Advanced DuPont Analysis Explanation", expanded=False):
+    st.markdown("The Advanced DuPont Analysis breaks down ROE into multiple components:")
+    st.latex(r"\text{ROE} = \text{Tax Burden} \times \text{Interest Burden} \times \text{Operating Margin} \times \text{Asset Turnover} \times \text{Equity Multiplier}")
+    st.markdown("Where:")
+    st.latex(r"\text{Tax Burden} = \frac{\text{Net Income}}{\text{EBT}}")
+    st.latex(r"\text{Interest Burden} = \frac{\text{EBT}}{\text{EBIT}}")
+    st.latex(r"\text{Operating Margin} = \frac{\text{EBIT}}{\text{Revenue}}")
+    st.latex(r"\text{Asset Turnover} = \frac{\text{Revenue}}{\text{Total Assets}}")
+    st.latex(r"\text{Equity Multiplier} = \frac{\text{Total Assets}}{\text{Total Equity}}")
+    st.markdown("This breakdown allows analysts to pinpoint whether changes in ROE are driven by tax factors, operating performance, asset efficiency, or financial leverage.")
+
+#st.sidebar.header("User Inputs")
+
+with st.sidebar.expander("Data Options", expanded=True):
+    ticker = st.text_input(
+        "Ticker Symbol",
+        value="AAPL",
+        help="Example: AAPL, TSLA, GOOG, etc."
+    )
+    period_type = st.selectbox(
+        "Select Data Period",
+        options=["annual", "quarter"],
+        help="Choose annual or quarterly data."
+    )
+    limit_periods = st.number_input(
+        "Number of Periods",
+        min_value=1,
+        max_value=20,
+        value=10,
+        help="Number of consecutive periods to analyze."
+    )
+
+run_analysis = st.sidebar.button("Run Analysis", help="Fetch data and generate charts.")
+
+if run_analysis:
+    with st.spinner("Fetching and processing data..."):
+        data = fetch_all_data(ticker=ticker, period=period_type, limit=limit_periods)
+        inc_stmt = data["income_statement"]
+        bs = data["balance_sheet"]
+        cf = data["cash_flow"]
+        prices = data["end_prices"]
+
+    if inc_stmt.empty or bs.empty or cf.empty:
+        st.error("One or more data sets are empty. Check inputs and try again.")
+    else:
+        # DuPont Analysis
+        st.subheader("Advanced DuPont Analysis")
+        st.markdown("Breaks down ROE into tax, interest, margin, turnover, and leverage factors.")
+        dupont_df = dupont_analysis_over_time(inc_stmt, bs)
+        plot_dupont_results(dupont_df)
+
+        with st.expander("Dynamic Interpretation: DuPont Analysis", expanded=False):
+            try:
+                # Sort periods and extract the latest period's data
+                sorted_periods = sorted(dupont_df.columns)
+                latest_period = sorted_periods[-1]
+                latest_data = dupont_df[latest_period]
+                advanced_roe = latest_data.get("Advanced DuPont ROE", None)
+                
+                st.markdown(f"**Latest Period:** {latest_period}")
+                if advanced_roe is not None:
+                    st.markdown(f"**Advanced DuPont ROE:** {advanced_roe:.2f}")
+                else:
+                    st.markdown("**Advanced DuPont ROE:** Data unavailable.")
+                
+                # Year-over-year change
+                if len(sorted_periods) > 1:
+                    prev_period = sorted_periods[-2]
+                    prev_roe = dupont_df[prev_period].get("Advanced DuPont ROE", None)
+                    if prev_roe and prev_roe != 0 and advanced_roe is not None:
+                        yoy_change = (advanced_roe - prev_roe) / abs(prev_roe)
+                        st.markdown(f"**Year-over-Year ROE Change:** {(yoy_change * 100):.2f}%")
+                    else:
+                        st.markdown("Year-over-year comparison unavailable due to missing data.")
+                
+                st.markdown("##### Key Drivers for the Latest Period:")
+                
+                # Tax Burden interpretation
+                tb = latest_data.get("Tax Burden", None)
+                if tb is not None:
+                    st.markdown(f"- **Tax Burden:** {tb:.2f}")
+                    if tb < 0.8:
+                        st.markdown("  - A lower tax burden means the firm retains a larger share of its pre-tax income, supporting profitability.")
+                    else:
+                        st.markdown("  - A higher tax burden indicates significant tax expense, which may erode net profit.")
+                else:
+                    st.markdown("- **Tax Burden:** Data unavailable.")
+                
+                # Interest Burden interpretation
+                ib = latest_data.get("Interest Burden", None)
+                if ib is not None:
+                    st.markdown(f"- **Interest Burden:** {ib:.2f}")
+                    if ib >= 0.9:
+                        st.markdown("  - An interest burden near 1 shows that interest expenses have minimal impact on pre-tax income.")
+                    else:
+                        st.markdown("  - A lower interest burden suggests that interest expenses significantly reduce pre-tax income.")
+                else:
+                    st.markdown("- **Interest Burden:** Data unavailable.")
+                
+                # Operating Margin interpretation
+                opm = latest_data.get("Operating Margin", None)
+                if opm is not None:
+                    st.markdown(f"- **Operating Margin:** {opm:.2f}")
+                    if opm > 0.15:
+                        st.markdown("  - A strong operating margin reflects efficient core operations.")
+                    else:
+                        st.markdown("  - A low operating margin could signal operational inefficiencies.")
+                else:
+                    st.markdown("- **Operating Margin:** Data unavailable.")
+                
+                # Asset Turnover interpretation
+                at = latest_data.get("Asset Turnover", None)
+                if at is not None:
+                    st.markdown(f"- **Asset Turnover:** {at:.2f}")
+                    if at > 1:
+                        st.markdown("  - Higher asset turnover indicates efficient utilization of assets to generate revenue.")
+                    else:
+                        st.markdown("  - Lower asset turnover may point to underutilized assets.")
+                else:
+                    st.markdown("- **Asset Turnover:** Data unavailable.")
+                
+                # Equity Multiplier interpretation
+                em = latest_data.get("Equity Multiplier", None)
+                if em is not None:
+                    st.markdown(f"- **Equity Multiplier:** {em:.2f}")
+                    if em > 2:
+                        st.markdown("  - A high equity multiplier suggests that the company is leveraging debt to boost ROE.")
+                    else:
+                        st.markdown("  - A low equity multiplier indicates a more conservative financing structure.")
+                else:
+                    st.markdown("- **Equity Multiplier:** Data unavailable.")
+                
+                # Overall conclusion based on ROE
+                if advanced_roe is not None:
+                    st.markdown("##### Overall Conclusion:")
+                    if advanced_roe < 0.05:
+                        st.markdown("The overall ROE is relatively low. This may be driven by high tax/interest burdens or operational inefficiencies.")
+                    elif advanced_roe < 0.15:
+                        st.markdown("The ROE is moderate. There are areas of strength, yet there remains room for improvement in efficiency or leveraging assets.")
+                    else:
+                        st.markdown("The ROE is strong, indicating robust operational efficiency and effective use of leverage.")
+            except Exception as e:
+                st.error("Dynamic interpretation unavailable for DuPont analysis.")
+
+
+        # Leverage & Equity Analysis
+        st.subheader("Leverage & Equity Analysis")
+        st.markdown("Shows how leverage metrics and equity levels change. Also links each period's stock price.")
+        em_df = compute_equity_multiplier_details(bs)
+        plot_leverage_metrics_plotly(em_df, prices)
+
+        with st.expander("Dynamic Interpretation: Leverage & Equity", expanded=False):
+            try:
+                # Sort fiscal years and extract the latest period's data
+                sorted_fy = sorted(em_df["Fiscal Year"])
+                latest_fy = sorted_fy[-1]
+                latest_row = em_df[em_df["Fiscal Year"] == latest_fy].iloc[0]
+                de = latest_row.get("Debt to Equity", None)
+                em_ratio = latest_row.get("Equity Multiplier", None)
+
+                st.markdown(f"**Latest Period:** {latest_fy}")
+                if de is not None:
+                    st.markdown(f"**Debt to Equity:** {de:.2f}")
+                else:
+                    st.markdown("**Debt to Equity:** Data unavailable.")
+                if em_ratio is not None:
+                    st.markdown(f"**Equity Multiplier:** {em_ratio:.2f}")
+                else:
+                    st.markdown("**Equity Multiplier:** Data unavailable.")
+
+                # Calculate Year-over-Year changes if available
+                if len(sorted_fy) > 1:
+                    prev_fy = sorted_fy[-2]
+                    prev_row = em_df[em_df["Fiscal Year"] == prev_fy].iloc[0]
+                    prev_de = prev_row.get("Debt to Equity", None)
+                    prev_em = prev_row.get("Equity Multiplier", None)
+                    if prev_de and de is not None and prev_de != 0:
+                        yoy_de_change = (de - prev_de) / abs(prev_de)
+                        st.markdown(f"**YoY Debt to Equity Change:** {(yoy_de_change * 100):.2f}%")
+                    else:
+                        st.markdown("YoY Debt to Equity change unavailable.")
+                    if prev_em and em_ratio is not None and prev_em != 0:
+                        yoy_em_change = (em_ratio - prev_em) / abs(prev_em)
+                        st.markdown(f"**YoY Equity Multiplier Change:** {(yoy_em_change * 100):.2f}%")
+                    else:
+                        st.markdown("YoY Equity Multiplier change unavailable.")
+
+                st.markdown("##### Detailed Interpretation:")
+                # Detailed interpretation for Debt-to-Equity
+                if de is not None:
+                    if de < 1:
+                        st.markdown("- **Low Debt to Equity:** The firm relies more on equity financing. This typically indicates lower financial risk and a conservative capital structure.")
+                    elif 1 <= de < 2:
+                        st.markdown("- **Moderate Debt to Equity:** The company maintains a balanced mix of debt and equity financing. This level may optimize returns while keeping risk manageable.")
+                    else:
+                        st.markdown("- **High Debt to Equity:** A high ratio suggests significant reliance on debt, which can amplify returns but also increases financial risk, especially in volatile market conditions.")
+                else:
+                    st.markdown("- **Debt to Equity data is missing.**")
+
+                # Detailed interpretation for Equity Multiplier
+                if em_ratio is not None:
+                    if em_ratio < 1.5:
+                        st.markdown("- **Low Equity Multiplier:** Indicates limited use of debt in financing assets, reflecting a conservative approach.")
+                    elif 1.5 <= em_ratio < 2.5:
+                        st.markdown("- **Moderate Equity Multiplier:** Suggests a balanced approach to leveraging, combining both debt and equity to finance assets.")
+                    else:
+                        st.markdown("- **High Equity Multiplier:** Indicates aggressive use of debt financing. While this can enhance ROE, it also raises the firm's exposure to interest rate fluctuations and market downturns.")
+                else:
+                    st.markdown("- **Equity Multiplier data is missing.**")
+            except Exception:
+                st.error("Dynamic interpretation unavailable for leverage & equity.")
+
+
+        # Combined Cash Flow and Profitability Metrics
+        st.subheader("Combined Cash Flow & ROE")
+        st.markdown("Shows net income, operating cash flow, CapEx, and return metrics together.")
+        ext_df = compute_equity_multiplier_details(bs)
+        ext_df = compute_additional_metrics(inc_stmt, ext_df)
+        ext_df = add_cash_flow_info(cf, ext_df)
+        plot_combined_metrics_plotly(ext_df, prices)
+
+        with st.expander("Dynamic Interpretation: Combined Metrics", expanded=False):
+            try:
+                # Get sorted fiscal years and pick the latest period
+                sorted_fy = sorted(ext_df["Fiscal Year"])
+                latest_fy = sorted_fy[-1]
+                latest_row = ext_df[ext_df["Fiscal Year"] == latest_fy].iloc[0]
+
+                # Extract key metrics for the latest period
+                net_income = latest_row.get("Net Income", None)
+                op_cf = latest_row.get("Operating Cash Flow", None)
+                capex = latest_row.get("CapEx", None)
+                roe = latest_row.get("ROE", None)
+
+                st.markdown(f"**Latest Period:** {latest_fy}")
+                if net_income is not None:
+                    st.markdown(f"- **Net Income:** {net_income:.2f}")
+                else:
+                    st.markdown("- **Net Income:** Data unavailable")
+                if op_cf is not None:
+                    st.markdown(f"- **Operating Cash Flow:** {op_cf:.2f}")
+                else:
+                    st.markdown("- **Operating Cash Flow:** Data unavailable")
+                if capex is not None:
+                    st.markdown(f"- **CapEx:** {capex:.2f}")
+                else:
+                    st.markdown("- **CapEx:** Data unavailable")
+                if roe is not None:
+                    st.markdown(f"- **ROE:** {roe:.2f}  _(Higher ROE typically indicates better efficiency in generating returns)_")
+                else:
+                    st.markdown("- **ROE:** Data unavailable")
+                
+                st.markdown("##### Detailed Analysis:")
+                
+                # Compare Operating Cash Flow to Net Income
+                if net_income is not None and op_cf is not None:
+                    if op_cf < net_income:
+                        st.markdown(
+                            "• **Operating Cash Flow is lower than Net Income.** This may indicate that non-cash items are inflating net income or that the company has challenges converting profits into cash. It might warrant a closer look at working capital management."
+                        )
+                    else:
+                        st.markdown(
+                            "• **Operating Cash Flow exceeds Net Income.** This suggests strong cash conversion from operations, which is a positive indicator of liquidity and operational efficiency."
+                        )
+                else:
+                    st.markdown("• **Operating Cash Flow vs. Net Income:** Insufficient data for comparison.")
+                
+                # Evaluate CapEx relative to Net Income
+                if capex is not None and net_income is not None:
+                    capex_ratio = capex / net_income if net_income != 0 else None
+                    if capex_ratio is not None:
+                        st.markdown(f"• **CapEx to Net Income Ratio:** {capex_ratio:.2f}")
+                        if capex_ratio > 1:
+                            st.markdown(
+                                "  - **High CapEx:** The company is investing heavily in fixed assets. While this can drive future growth, it may suppress short-term profitability."
+                                "  - **High CapEx:** The company is investing heavily in fixed assets. While this can drive future growth, it may suppress short-term profitability."
+                            )
+                        else:
+                            st.markdown(
+                                "  - **Moderate CapEx:** Investment levels appear balanced relative to net income, which may support sustainable growth without overly impacting current profits."
+                            )
+                    else:
+                        st.markdown("• **CapEx Analysis:** Unable to compute ratio due to zero or missing net income.")
+                else:
+                    st.markdown("• **CapEx Analysis:** Insufficient data for evaluation.")
+
+                # Year-over-Year comparison for Net Income
+                if len(sorted_fy) > 1 and net_income is not None:
+                    prev_fy = sorted_fy[-2]
+                    prev_row = ext_df[ext_df["Fiscal Year"] == prev_fy].iloc[0]
+                    prev_net = prev_row.get("Net Income", None)
+                    if prev_net is not None and prev_net != 0:
+                        net_yoy = (net_income - prev_net) / abs(prev_net)
+                        st.markdown(f"• **Year-over-Year Net Income Change:** {(net_yoy * 100):.2f}%")
+                        if net_yoy > 0:
+                            st.markdown("  - Net income has increased compared to the previous period, indicating potential growth or improved efficiency.")
+                        else:
+                            st.markdown("  - Net income has declined compared to the previous period, which may signal operational challenges or increased expenses.")
+                    else:
+                        st.markdown("• **Year-over-Year Net Income Change:** Data unavailable for previous period.")
+                else:
+                    st.markdown("• **Year-over-Year Comparison:** Not enough periods to compute change.")
+
+            except Exception as e:
+                st.error("Dynamic interpretation unavailable for combined metrics.")
+
+
+
+
+else:
+    st.info("Set your inputs and click Run Analysis.")
+hide_streamlit_style = """
+<style>
+#MainMenu {visibility: hidden;}
+footer {visibility: hidden;}
+</style>
+"""
+st.markdown(hide_streamlit_style, unsafe_allow_html=True)