fix async fundamental analyzer

src/core/fundamental_analysis/async_fundamental_analyzer.py

@@ -2,7 +2,6 @@ import asyncio
 from typing import Dict, Any, List, Optional
 
 import pandas as pd
-import yfinance as yf
 
 from src.core.fundamental_analysis.core_models import TickerData, FinancialMetrics, DCFResult
 from src.core.fundamental_analysis.async_data_fetcher import AsyncDataFetcher
@@ -15,59 +14,66 @@ from src.core.fundamental_analysis.financial_utils import FinancialUtils
 
 
 class AsyncFundamentalAnalyzer:
-    """Main async class for fundamental analysis"""
+    """
+    Main orchestrator for performing asynchronous fundamental analysis on a stock ticker.
+    Manages data fetching, metric calculation, valuation, and reporting.
+    """
 
     def __init__(self, ticker: str, max_workers: int = 5):
         self.ticker = ticker.upper()
+        # Each analyzer instance manages its own data fetcher
         self.data_fetcher = AsyncDataFetcher(max_workers=max_workers)
         self.dcf_calculator = DCFCalculator()
         self.report_generator = ReportGenerator()
         self.peer_comparison = PeerComparison(self.data_fetcher)
-
-        # Cache for ticker data
         self._ticker_data: Optional[TickerData] = None
 
     async def _ensure_ticker_data(self) -> TickerData:
-        """Ensure ticker data is loaded"""
+        """Lazily fetches and caches the ticker's core financial data."""
         if self._ticker_data is None:
             self._ticker_data = await self.data_fetcher.fetch_ticker_data(self.ticker)
         return self._ticker_data
 
     async def calculate_metrics(self) -> FinancialMetrics:
-        """Calculate all financial metrics asynchronously"""
+        """Calculates a comprehensive set of financial metrics."""
         ticker_data = await self._ensure_ticker_data()
         data_extractor = DataExtractor(ticker_data)
         metrics_calculator = MetricsCalculator(data_extractor)
         return await metrics_calculator.calculate_all_metrics()
 
-    async def calculate_dcf(self, base_fcf: Optional[float], growth_rate: float = 0.05,
-                            discount_rate: float = 0.10, projection_years: int = 5,
-                            shares_outstanding: Optional[float] = None) -> DCFResult:
-        """Calculate DCF valuation asynchronously"""
-        return await self.dcf_calculator.calculate_dcf(
-            base_fcf=base_fcf,
+    # This method can remain async to be compatible with asyncio.gather
+    async def calculate_dcf(self, metrics: FinancialMetrics, growth_rate: float,
+                            discount_rate: float, projection_years: int) -> DCFResult:
+        """
+        Wraps the synchronous DCF calculation.
+        This method is async to allow it to be seamlessly used in asyncio.gather streams.
+        """
+        # FIX: Removed 'await' as dcf_calculator.calculate_dcf is a synchronous method.
+        return self.dcf_calculator.calculate_dcf(
+            base_fcf=metrics.free_cash_flow,
             growth_rate=growth_rate,
             discount_rate=discount_rate,
             projection_years=projection_years,
-            shares_outstanding=shares_outstanding
+            shares_outstanding=metrics.shares_outstanding
         )
 
     async def compare_with_peers(self, sort_by: str = "P/E") -> pd.DataFrame:
-        """Compare with MAG7 peers asynchronously"""
+        """Generates a peer comparison DataFrame against the MAG7 stocks."""
         return await self.peer_comparison.compare_with_mag7(self.ticker, sort_by)
 
     async def generate_report(self, sort_by: str = "P/E", dcf_growth: float = 0.05,
                               dcf_discount: float = 0.10, dcf_years: int = 5) -> str:
-        """Generate comprehensive fundamental analysis report asynchronously"""
-        # Run all operations concurrently where possible
+        """Generates a comprehensive fundamental analysis report."""
+        # FIX: Run independent I/O-bound tasks concurrently for maximum efficiency.
         metrics_task = self.calculate_metrics()
         peer_comparison_task = self.compare_with_peers(sort_by=sort_by)
 
-        # Wait for metrics first as DCF depends on it
-        metrics = await metrics_task
+        # Await both tasks together
+        metrics, peer_comparison = await asyncio.gather(metrics_task, peer_comparison_task)
 
-        # Calculate DCF and wait for peer comparison
-        dcf_task = self.calculate_dcf(
+        # The DCF calculation is CPU-bound and fast, so it doesn't need its own task.
+        # It can be called directly after its dependencies (metrics) are ready.
+        dcf_result = self.dcf_calculator.calculate_dcf(
             base_fcf=metrics.free_cash_flow,
             growth_rate=dcf_growth,
             discount_rate=dcf_discount,
@@ -75,8 +81,6 @@ class AsyncFundamentalAnalyzer:
             shares_outstanding=metrics.shares_outstanding
         )
 
-        dcf_result, peer_comparison = await asyncio.gather(dcf_task, peer_comparison_task)
-
         return await self.report_generator.generate_telegram_report(
             ticker=self.ticker,
             metrics=metrics,
@@ -85,844 +89,79 @@ class AsyncFundamentalAnalyzer:
             sort_by=sort_by
         )
 
-    async def batch_analyze(self, tickers: List[str]) -> Dict[str, str]:
-        """Analyze multiple tickers concurrently and return reports"""
-        analyzers = [AsyncFundamentalAnalyzer(ticker) for ticker in tickers]
-        tasks = [analyzer.generate_report() for analyzer in analyzers]
+    @staticmethod
+    async def batch_analyze(tickers: List[str]) -> Dict[str, str]:
+        """Analyzes multiple tickers concurrently and returns a dictionary of reports."""
+
+        async def _analyze_one(ticker):
+            async with AsyncFundamentalAnalyzer(ticker) as analyzer:
+                return await analyzer.generate_report()
 
+        tasks = [_analyze_one(ticker) for ticker in tickers]
         results = await asyncio.gather(*tasks, return_exceptions=True)
 
         reports = {}
-        for i, result in enumerate(results):
+        for ticker, result in zip(tickers, results):
             if isinstance(result, Exception):
-                reports[tickers[i]] = f"Error analyzing {tickers[i]}: {str(result)}"
+                reports[ticker] = f"Error analyzing {ticker}: {result}"
             else:
-                reports[tickers[i]] = result
-
+                reports[ticker] = result
         return reports
 
     async def __aenter__(self):
-        """Async context manager entry"""
+        """Async context manager entry: enters the data_fetcher context."""
+        await self.data_fetcher.__aenter__()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
-        """Async context manager exit - cleanup resources"""
-        # Cleanup is handled by AsyncDataFetcher's __del__ method
-        pass
+        """Async context manager exit: properly exits the data_fetcher context."""
+        await self.data_fetcher.__aexit__(exc_type, exc_val, exc_tb)
+
 
+# --- Convenience Functions ---
 
-# Utility functions for easier usage
 async def analyze_ticker(ticker: str, **kwargs) -> str:
-    """Convenience function to analyze a single ticker"""
+    """Convenience function to analyze and generate a report for a single ticker."""
     async with AsyncFundamentalAnalyzer(ticker) as analyzer:
         return await analyzer.generate_report(**kwargs)
 
 
-async def analyze_multiple_tickers(tickers: List[str], **kwargs) -> Dict[str, str]:
-    """Convenience function to analyze multiple tickers concurrently"""
-
-    async def analyze_single(ticker):
-        async with AsyncFundamentalAnalyzer(ticker) as analyzer:
-            return await analyzer.generate_report(**kwargs)
-
-    tasks = [analyze_single(ticker) for ticker in tickers]
-    results = await asyncio.gather(*tasks, return_exceptions=True)
-
-    reports = {}
-    for i, result in enumerate(results):
-        if isinstance(result, Exception):
-            reports[tickers[i]] = f"Error analyzing {tickers[i]}: {str(result)}"
-        else:
-            reports[tickers[i]] = result
-
-    return reports
-
-
 async def quick_comparison(tickers: List[str], sort_by: str = "P/E") -> pd.DataFrame:
-    """Quick comparison of multiple tickers"""
-    data_fetcher = AsyncDataFetcher()
-    peer_comparison = PeerComparison(data_fetcher)
-
-    # For quick comparison, we'll fetch all tickers and create a comparison table
-    ticker_data_dict = await data_fetcher.fetch_multiple_tickers(tickers)
-
-    rows: List[Dict[str, Any]] = []
-    utils = FinancialUtils()
-
-    for ticker in tickers:
-        if ticker not in ticker_data_dict:
-            continue
+    """
+    Generates a comparison DataFrame for a list of tickers using key metrics.
+    FIX: This function now reuses the existing calculation modules to ensure consistency.
+    """
+    rows = []
 
+    async def get_metrics_for_ticker(ticker):
         try:
-            ticker_data = ticker_data_dict[ticker]
-            info = ticker_data.info
-
-            price = info.get("currentPrice") or info.get("regularMarketPrice")
-            eps = info.get("trailingEps")
-            book_value = info.get("bookValue")
-            market_cap = info.get("marketCap")
-            cash = info.get("totalCash")
-            debt = info.get("totalDebt")
-            ebitda = info.get("ebitda")
+            async with AsyncFundamentalAnalyzer(ticker) as analyzer:
+                return await analyzer.calculate_metrics()
+        except Exception as e:
+            print(f"Could not fetch metrics for {ticker}: {e}")
+            return None
 
-            pe = utils.safe_divide(price, eps)
-            pb = utils.safe_divide(price, book_value)
-            ev = (market_cap or 0) + (debt or 0) - (cash or 0) if market_cap is not None else None
-            ev_ebitda = utils.safe_divide(ev, ebitda)
+    tasks = [get_metrics_for_ticker(ticker) for ticker in tickers]
+    results = await asyncio.gather(*tasks)
 
+    for ticker, metrics in zip(tickers, results):
+        if metrics:
             rows.append({
                 "Ticker": ticker,
-                "Price": price,
-                "Market Cap": market_cap,
-                "P/E": pe,
-                "P/B": pb,
-                "EV/EBITDA": ev_ebitda,
+                "Price": metrics.price,
+                "Market Cap": metrics.market_cap,
+                "P/E": metrics.pe_ratio,
+                "P/B": metrics.pb_ratio,
+                "EV/EBITDA": metrics.ev_ebitda,
+                "Net Margin": metrics.net_margin,
+                "ROE": metrics.roe
             })
-        except Exception as e:
-            print(f"Error processing {ticker}: {e}")
-            continue
+
+    if not rows:
+        return pd.DataFrame()
 
     df = pd.DataFrame(rows)
     if sort_by in df.columns:
-        df = df.sort_values(by=sort_by, na_position='last')
-
-    return df.reset_index(drop=True)
-
-
-
-
-
-'''
-
-"""
-Refactored asynchronous comprehensive fundamental analysis module with human interpretations
-
-Key fixes made:
-- PEG calculation fixed (handles decimals vs percentages and avoids incorrect *100 multiplication)
-- Free Cash Flow calculation uses absolute CAPEX sign correctly
-- AsyncDataFetcher implements async context manager and optional concurrency semaphore
-- Minor robustness improvements in extractors and metric calculator
-- Removed unused imports
-
-Dependencies: yfinance, pandas, numpy, aiohttp (optional), asyncio
-"""
-
-from __future__ import annotations
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
-from typing import Dict, Any, List, Optional
-from dataclasses import dataclass
-from enum import Enum
-
-import numpy as np
-import pandas as pd
-import yfinance as yf
-
-# Constants
-MAG7_TICKERS = ["AAPL", "MSFT", "GOOGL", "AMZN", "NVDA", "META", "TSLA"]
-
-
-class MetricCategory(Enum):
-    """Categories for financial metrics"""
-    VALUATION = "valuation"
-    PROFITABILITY = "profitability"
-    LEVERAGE = "leverage"
-    CASH_FLOW = "cash_flow"
-
-
-@dataclass
-class FinancialMetrics:
-    """Container for calculated financial metrics"""
-    price: Optional[float] = None
-    market_cap: Optional[float] = None
-    shares_outstanding: Optional[float] = None
-    pe_ratio: Optional[float] = None
-    pb_ratio: Optional[float] = None
-    peg_ratio: Optional[float] = None
-    ev_ebitda: Optional[float] = None
-    ps_ratio: Optional[float] = None
-    pcf_ratio: Optional[float] = None
-    ev_sales: Optional[float] = None
-    dividend_yield: Optional[float] = None
-    roe: Optional[float] = None
-    roa: Optional[float] = None
-    roic: Optional[float] = None
-    roce: Optional[float] = None
-    gross_margin: Optional[float] = None
-    operating_margin: Optional[float] = None
-    net_margin: Optional[float] = None
-    ebitda_margin: Optional[float] = None
-    current_ratio: Optional[float] = None
-    quick_ratio: Optional[float] = None
-    cash_ratio: Optional[float] = None
-    ocf_to_current_liabilities: Optional[float] = None
-    asset_turnover: Optional[float] = None
-    inventory_turnover: Optional[float] = None
-    receivables_turnover: Optional[float] = None
-    days_sales_outstanding: Optional[float] = None
-    debt_to_equity: Optional[float] = None
-    debt_to_assets: Optional[float] = None
-    equity_ratio: Optional[float] = None
-    debt_to_capital: Optional[float] = None
-    interest_coverage: Optional[float] = None
-    operating_cash_flow: Optional[float] = None
-    capex: Optional[float] = None
-    free_cash_flow: Optional[float] = None
-    fcf_yield: Optional[float] = None
-    quality_of_earnings: Optional[float] = None
-    revenue_growth: Optional[float] = None
-    earnings_growth: Optional[float] = None
-    book_value_growth: Optional[float] = None
-    altman_z_score: Optional[float] = None
-    piotroski_score: Optional[int] = None
-    enterprise_value: Optional[float] = None
-    book_value: Optional[float] = None
-    eps: Optional[float] = None
-
-
-@dataclass
-class DCFResult:
-    fair_value_per_share: Optional[float] = None
-    intrinsic_value: Optional[float] = None
-    upside_downside: Optional[float] = None
-
-
-@dataclass
-class TickerData:
-    ticker: str
-    info: Dict[str, Any]
-    financials: pd.DataFrame
-    balance_sheet: pd.DataFrame
-    cashflow: pd.DataFrame
-
-
-class FinancialUtils:
-    @staticmethod
-    def safe_divide(numerator: Optional[float], denominator: Optional[float]) -> Optional[float]:
-        try:
-            if numerator is None or denominator is None:
-                return None
-            if isinstance(numerator, (int, float, np.number)) and isinstance(denominator, (int, float, np.number)):
-                if denominator == 0:
-                    return None
-                return float(numerator) / float(denominator)
-        except Exception:
-            return None
-        return None
-
-    @staticmethod
-    def format_number(value: Optional[float], decimal_places: int = 2, suffix: str = "") -> str:
-        if value is None or (isinstance(value, float) and (np.isnan(value) or np.isinf(value))):
-            return "—"
-        try:
-            abs_value = abs(value)
-            if abs_value >= 1_000_000_000_000:
-                return f"{value/1_000_000_000_000:.{decimal_places}f}T{suffix}"
-            elif abs_value >= 1_000_000_000:
-                return f"{value/1_000_000_000:.{decimal_places}f}B{suffix}"
-            elif abs_value >= 1_000_000:
-                return f"{value/1_000_000:.{decimal_places}f}M{suffix}"
-            elif abs_value >= 1_000:
-                return f"{value/1_000:.{decimal_places}f}K{suffix}"
-            else:
-                return f"{value:.{decimal_places}f}{suffix}"
-        except Exception:
-            return "—"
-
-    @staticmethod
-    def format_percentage(value: Optional[float], decimal_places: int = 2) -> str:
-        if value is None or (isinstance(value, float) and (np.isnan(value) or np.isinf(value))):
-            return "—"
-        try:
-            return f"{value*100:.{decimal_places}f}%"
-        except Exception:
-            return "—"
-
-
-class MetricInterpreter:
-    # (unchanged for brevity) - keep existing interpret_* methods
-    @staticmethod
-    def interpret_pe_ratio(pe: Optional[float]) -> str:
-        if pe is None or pe <= 0:
-            return "No earnings or insufficient data"
-        elif pe < 10:
-            return "Cheap: market expects stagnation/risks"
-        elif pe < 20:
-            return "Fair valuation range"
-        elif pe < 35:
-            return "Premium: expects sustained growth"
-        else:
-            return "High premium: expects rapid growth or overheated"
-
-    @staticmethod
-    def interpret_pb_ratio(pb: Optional[float]) -> str:
-        if pb is None or pb <= 0:
-            return "No data or negative equity"
-        elif pb < 1:
-            return "Below book value: market expects problems"
-        elif pb < 3:
-            return "Moderate: within normal range"
-        elif pb < 6:
-            return "High: strong brand/margins/growth"
-        else:
-            return "Very high: strong growth expectations"
-
-    @staticmethod
-    def interpret_peg_ratio(peg: Optional[float]) -> str:
-        if peg is None or peg <= 0:
-            return "No growth data available"
-        elif peg < 0.8:
-            return "Cheap relative to growth"
-        elif peg <= 1.2:
-            return "Fair price relative to growth"
-        else:
-            return "Expensive relative to growth"
-
-    @staticmethod
-    def interpret_ps_ratio(ps: Optional[float]) -> str:
-        if ps is None or ps <= 0:
-            return "No data available"
-        elif ps < 2:
-            return "Reasonable sales multiple"
-        elif ps < 5:
-            return "Moderate sales premium"
-        else:
-            return "High sales premium"
-
-    @staticmethod
-    def interpret_ev_ebitda(val: Optional[float]) -> str:
-        if val is None or val <= 0:
-            return "No data available"
-        elif val < 6:
-            return "Cheap/questions about earnings quality"
-        elif val <= 12:
-            return "Normal range for mature businesses"
-        else:
-            return "High: market expects growth acceleration"
-
-    @staticmethod
-    def interpret_roe(roe: Optional[float]) -> str:
-        if roe is None or roe <= 0:
-            return "Low return on equity"
-        elif roe < 0.15:
-            return "Moderate efficiency"
-        elif roe < 0.4:
-            return "High efficiency"
-        else:
-            return "Very high: possible leverage effect"
-
-    @staticmethod
-    def interpret_roa(roa: Optional[float]) -> str:
-        if roa is None or roa <= 0:
-            return "Low asset efficiency"
-        elif roa < 0.05:
-            return "Moderate for capital-intensive industries"
-        elif roa < 0.12:
-            return "Good asset utilization"
-        else:
-            return "Excellent asset efficiency"
-
-    @staticmethod
-    def interpret_roic(roic: Optional[float]) -> str:
-        if roic is None or roic <= 0:
-            return "Low capital efficiency"
-        elif roic < 0.10:
-            return "Below cost of capital"
-        elif roic < 0.20:
-            return "Decent capital allocation"
-        else:
-            return "Excellent capital allocation"
-
-    @staticmethod
-    def interpret_current_ratio(ratio: Optional[float]) -> str:
-        if ratio is None or ratio <= 0:
-            return "Poor liquidity position"
-        elif ratio < 1:
-            return "Liquidity concerns"
-        elif ratio < 2:
-            return "Adequate liquidity"
-        else:
-            return "Strong liquidity position"
-
-    @staticmethod
-    def interpret_quick_ratio(ratio: Optional[float]) -> str:
-        if ratio is None or ratio <= 0:
-            return "Poor short-term liquidity"
-        elif ratio < 1:
-            return "Tight liquidity"
-        else:
-            return "Good short-term liquidity"
-
-    @staticmethod
-    def interpret_asset_turnover(turnover: Optional[float]) -> str:
-        if turnover is None or turnover <= 0:
-            return "Poor asset utilization"
-        elif turnover < 0.5:
-            return "Low asset efficiency"
-        elif turnover < 1.5:
-            return "Moderate asset efficiency"
-        else:
-            return "High asset efficiency"
-
-    @staticmethod
-    def interpret_margin(margin: Optional[float], margin_type: str) -> str:
-        if margin is None or margin < 0:
-            return f"Narrow/negative {margin_type} margin"
-        if margin_type == "gross":
-            if margin < 0.3:
-                return "Low gross margin"
-            elif margin < 0.6:
-                return "Healthy gross margin"
-            else:
-                return "Very high gross margin"
-        elif margin_type == "operating":
-            if margin < 0.1:
-                return "Low operating margin"
-            elif margin < 0.25:
-                return "Sustainable operating margin"
-            else:
-                return "High operating margin"
-        elif margin_type == "net":
-            if margin < 0.05:
-                return "Thin net margin"
-            elif margin < 0.15:
-                return "Normal net margin"
-            else:
-                return "High net margin"
-        elif margin_type == "ebitda":
-            if margin < 0.1:
-                return "Low EBITDA margin"
-            elif margin < 0.25:
-                return "Healthy EBITDA margin"
-            else:
-                return "High EBITDA margin"
-        return ""
-
-    @staticmethod
-    def interpret_debt_equity(de: Optional[float]) -> str:
-        if de is None or de < 0:
-            return "No data available"
-        elif de < 1:
-            return "Moderate debt load"
-        elif de < 2:
-            return "Elevated debt load"
-        else:
-            return "High/critical debt load"
-
-    @staticmethod
-    def interpret_debt_to_assets(dta: Optional[float]) -> str:
-        if dta is None or dta < 0:
-            return "No data available"
-        elif dta < 0.3:
-            return "Conservative debt level"
-        elif dta < 0.6:
-            return "Moderate debt level"
-        else:
-            return "High debt level"
-
-    @staticmethod
-    def interpret_interest_coverage(icr: Optional[float]) -> str:
-        if icr is None or icr <= 0:
-            return "No/negative interest coverage"
-        elif icr < 1.5:
-            return "Risky: low coverage"
-        elif icr < 3:
-            return "Moderate coverage"
-        else:
-            return "Comfortable coverage"
-
-    @staticmethod
-    def interpret_fcf_yield(yield_val: Optional[float]) -> str:
-        if yield_val is None or yield_val <= 0:
-            return "Low/negative FCF yield"
-        elif yield_val < 0.02:
-            return "Low FCF yield"
-        elif yield_val < 0.05:
-            return "Moderate FCF yield"
-        elif yield_val < 0.08:
-            return "Good FCF yield"
-        else:
-            return "High FCF yield"
-
-    @staticmethod
-    def interpret_quality_of_earnings(qoe: Optional[float]) -> str:
-        if qoe is None:
-            return "No data available"
-        elif qoe < 0.8:
-            return "Poor earnings quality"
-        elif qoe < 1.2:
-            return "Good earnings quality"
-        else:
-            return "Excellent earnings quality"
-
-    @staticmethod
-    def interpret_altman_z_score(z_score: Optional[float]) -> str:
-        if z_score is None:
-            return "No data available"
-        elif z_score < 1.8:
-            return "High bankruptcy risk"
-        elif z_score < 3.0:
-            return "Moderate risk zone"
-        else:
-            return "Safe zone"
-
-
-class AsyncDataFetcher:
-    """Async yfinance fetcher with optional concurrency throttling and context manager support."""
-
-    def __init__(self, max_workers: int = 5, max_concurrency: int | None = None):
-        self.max_workers = max_workers
-        self.executor: Optional[ThreadPoolExecutor] = None
-        self.semaphore = asyncio.Semaphore(max_concurrency) if max_concurrency is not None else None
-
-    async def __aenter__(self):
-        self.executor = ThreadPoolExecutor(max_workers=self.max_workers)
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb):
-        if self.executor:
-            self.executor.shutdown(wait=False)
-            self.executor = None
-
-    async def fetch_ticker_data(self, ticker: str) -> TickerData:
-        loop = asyncio.get_event_loop()
-
-        async def _maybe_wait():
-            if self.semaphore:
-                await self.semaphore.acquire()
-
-        async def _maybe_release():
-            if self.semaphore:
-                self.semaphore.release()
-
-        await _maybe_wait()
-
-        def _fetch_data():
-            try:
-                ticker_obj = yf.Ticker(ticker)
-                return TickerData(
-                    ticker=ticker,
-                    info=getattr(ticker_obj, "info", {}) or {},
-                    financials=getattr(ticker_obj, "financials", pd.DataFrame()),
-                    balance_sheet=getattr(ticker_obj, "balance_sheet", pd.DataFrame()),
-                    cashflow=getattr(ticker_obj, "cashflow", pd.DataFrame())
-                )
-            except Exception as e:
-                # keep errors quiet in production; consider logging
-                return TickerData(ticker=ticker, info={}, financials=pd.DataFrame(), balance_sheet=pd.DataFrame(), cashflow=pd.DataFrame())
-
-        try:
-            result = await loop.run_in_executor(self.executor, _fetch_data)
-        finally:
-            await _maybe_release()
-
-        return result
-
-    async def fetch_multiple_tickers(self, tickers: List[str]) -> Dict[str, TickerData]:
-        tasks = [self.fetch_ticker_data(t) for t in tickers]
-        results = await asyncio.gather(*tasks, return_exceptions=True)
-        out: Dict[str, TickerData] = {}
-        for r in results:
-            if isinstance(r, Exception):
-                continue
-            out[r.ticker] = r
-        return out
-
-
-class DataExtractor:
-    def __init__(self, ticker_data: TickerData):
-        self.ticker_data = ticker_data
-        self.info = ticker_data.info or {}
-        self.financials = ticker_data.financials or pd.DataFrame()
-        self.balance_sheet = ticker_data.balance_sheet or pd.DataFrame()
-        self.cashflow = ticker_data.cashflow or pd.DataFrame()
-
-    def _first_non_na_from_index(self, df: pd.DataFrame, keys: List[str]) -> Optional[float]:
-        for k in keys:
-            if k in df.index:
-                vals = df.loc[k].dropna()
-                if len(vals) > 0:
-                    try:
-                        return float(vals.iloc[0])
-                    except Exception:
-                        continue
-        return None
-
-    def get_balance_sheet_item(self, item: str, fallback_names: List[str] | None = None) -> Optional[float]:
-        if fallback_names is None:
-            fallback_names = []
-        keys = [item] + fallback_names
-        try:
-            v = self._first_non_na_from_index(self.balance_sheet, keys)
-            if v is not None:
-                return v
-        except Exception:
-            pass
-        # fallback to info dict
-        val = self.info.get(item)
-        return float(val) if val is not None else None
-
-    def get_financial_item(self, item: str, fallback_names: List[str] | None = None) -> Optional[float]:
-        if fallback_names is None:
-            fallback_names = []
-        keys = [item] + fallback_names
-        try:
-            v = self._first_non_na_from_index(self.financials, keys)
-            if v is not None:
-                return v
-        except Exception:
-            pass
-        val = self.info.get(item)
-        return float(val) if val is not None else None
-
-    def get_cashflow_item(self, item: str, fallback_names: List[str] | None = None) -> Optional[float]:
-        if fallback_names is None:
-            fallback_names = []
-        keys = [item] + fallback_names
-        try:
-            v = self._first_non_na_from_index(self.cashflow, keys)
-            if v is not None:
-                return v
-        except Exception:
-            pass
-        val = self.info.get(item)
-        return float(val) if val is not None else None
-
-    def get_historical_data(self, item: str, periods: int) -> List[Optional[float]]:
-        try:
-            if item in self.financials.index and not self.financials.empty:
-                values = self.financials.loc[item].dropna()
-                return [float(values.iloc[i]) if i < len(values) else None for i in range(min(periods, len(values)))]
-        except Exception:
-            pass
-        return [None] * periods
-
-
-class DCFCalculator:
-    @staticmethod
-    async def calculate_dcf(base_fcf: Optional[float],
-                           growth_rate: float = 0.05,
-                           discount_rate: float = 0.10,
-                           projection_years: int = 5,
-                           shares_outstanding: Optional[float] = None) -> DCFResult:
-        if base_fcf is None or base_fcf <= 0:
-            return DCFResult()
-        loop = asyncio.get_event_loop()
-
-        def _calculate():
-            future_fcfs = [base_fcf * ((1 + growth_rate) ** t) for t in range(1, projection_years + 1)]
-            pv_fcfs = [fcf / ((1 + discount_rate) ** t) for t, fcf in enumerate(future_fcfs, 1)]
-
-            if discount_rate > growth_rate:
-                terminal_value = future_fcfs[-1] * (1 + growth_rate) / (discount_rate - growth_rate)
-                pv_terminal = terminal_value / ((1 + discount_rate) ** projection_years)
-            else:
-                pv_terminal = future_fcfs[-1] / ((1 + discount_rate) ** projection_years)
-
-            intrinsic_value = sum(pv_fcfs) + pv_terminal
-            fair_value_per_share = None
-            if shares_outstanding and shares_outstanding > 0:
-                fair_value_per_share = intrinsic_value / shares_outstanding
-            return DCFResult(fair_value_per_share=fair_value_per_share, intrinsic_value=intrinsic_value)
-
-        return await loop.run_in_executor(None, _calculate)
-
-
-class MetricsCalculator:
-    def __init__(self, data_extractor: DataExtractor):
-        self.extractor = data_extractor
-        self.utils = FinancialUtils()
-
-    async def calculate_all_metrics(self) -> FinancialMetrics:
-        loop = asyncio.get_event_loop()
-
-        def _calculate():
-            info = self.extractor.info or {}
-
-            price = info.get("currentPrice") or info.get("regularMarketPrice") or info.get("previousClose")
-            market_cap = info.get("marketCap")
-            shares_out = info.get("sharesOutstanding") or info.get("impliedSharesOutstanding")
-            eps = info.get("trailingEps") or info.get("forwardEps")
-            book_value = info.get("bookValue")
-
-            net_income = (info.get("netIncomeToCommon") or self.extractor.get_financial_item("Net Income", ["Net Income Common Stockholders", "Net Income Available To Common Stockholders"]))
-            revenue = (info.get("totalRevenue") or self.extractor.get_financial_item("Total Revenue", ["Revenue", "Total Revenues"]))
-            ebitda = (info.get("ebitda") or self.extractor.get_financial_item("EBITDA", ["Ebitda"]))
-            ebit = (info.get("ebit") or self.extractor.get_financial_item("EBIT", ["Operating Income"]))
-
-            equity = self.extractor.get_balance_sheet_item("Total Stockholder Equity", ["Stockholders Equity", "Total Equity", "Shareholders Equity"])
-            assets = self.extractor.get_balance_sheet_item("Total Assets", ["Total Assets"])
-            current_assets = self.extractor.get_balance_sheet_item("Current Assets", ["Total Current Assets"])
-            current_liabilities = self.extractor.get_balance_sheet_item("Current Liabilities", ["Total Current Liabilities"])
-
-            cash = (self.extractor.get_balance_sheet_item("Cash", ["Cash And Cash Equivalents", "Cash and Short Term Investments"]) or info.get("totalCash"))
-            inventory = self.extractor.get_balance_sheet_item("Inventory", ["Inventories"]) 
-            accounts_receivable = self.extractor.get_balance_sheet_item("Accounts Receivable", ["Net Receivables", "Receivables"]) 
-
-            total_debt = (info.get("totalDebt") or self.extractor.get_balance_sheet_item("Total Debt", ["Long Term Debt", "Short Long Term Debt"]))
-            liabilities = self.extractor.get_balance_sheet_item("Total Liab", ["Total Liabilities Net Minority Interest"]) 
-
-            interest_expense = self.extractor.get_financial_item("Interest Expense", ["Interest Expense Non Operating"]) 
-
-            operating_cash_flow = self.extractor.get_cashflow_item("Total Cash From Operating Activities", ["Operating Cash Flow", "Cash From Operating Activities"]) 
-            capex = self.extractor.get_cashflow_item("Capital Expenditures", ["Capital Expenditure", "Purchase Of Property Plant Equipment"]) 
-
-            if capex is not None:
-                capex = abs(capex)  # ensure capex treated as cash outflow magnitude
-
-            earnings_growth = info.get("earningsQuarterlyGrowth") or info.get("earningsGrowth")
-            revenue_growth = info.get("revenueGrowth")
-
-            historical_revenue = self.extractor.get_historical_data("Total Revenue", 2)
-            if len(historical_revenue) >= 2 and historical_revenue[0] and historical_revenue[1]:
-                hist_growth = (historical_revenue[0] - historical_revenue[1]) / abs(historical_revenue[1])
-                revenue_growth = revenue_growth or hist_growth
-
-            gross_margin = info.get("grossMargins")
-            operating_margin = info.get("operatingMargins")
-            profit_margins = info.get("profitMargins")
-
-            if revenue and revenue > 0:
-                if not operating_margin and ebit:
-                    operating_margin = ebit / revenue
-                if not profit_margins and net_income:
-                    profit_margins = net_income / revenue
-
-            dividend_yield = info.get("dividendYield")
-
-            enterprise_value = None
-            if market_cap is not None:
-                enterprise_value = market_cap + (total_debt or 0) - (cash or 0)
-
-            free_cash_flow = None
-            if operating_cash_flow is not None:
-                if capex is not None:
-                    free_cash_flow = operating_cash_flow - capex
-                else:
-                    free_cash_flow = operating_cash_flow
-
-            pe_ratio = self.utils.safe_divide(price, eps)
-            pb_ratio = self.utils.safe_divide(price, book_value)
-
-            # PEG ratio: ensure earnings_growth is in decimal (e.g., 0.12 for 12%)
-            peg_ratio = None
-            if pe_ratio is not None and earnings_growth is not None:
-                try:
-                    g = float(earnings_growth)
-                    # If Yahoo returns large numbers like 12 for 12%, convert
-                    if abs(g) > 1:
-                        g = g / 100.0
-                    # ignore extremely small growth rates that would distort PEG
-                    if abs(g) >= 0.01:
-                        peg_ratio = self.utils.safe_divide(pe_ratio, g)
-                except Exception:
-                    peg_ratio = None
-
-            ps_ratio = self.utils.safe_divide(market_cap, revenue)
-            pcf_ratio = self.utils.safe_divide(market_cap, operating_cash_flow)
-            ev_ebitda = self.utils.safe_divide(enterprise_value, ebitda)
-            ev_sales = self.utils.safe_divide(enterprise_value, revenue)
-
-            roe = self.utils.safe_divide(net_income, equity)
-            roa = self.utils.safe_divide(net_income, assets)
-
-            invested_capital = (equity or 0) + (total_debt or 0)
-            roic = self.utils.safe_divide(net_income, invested_capital) if invested_capital > 0 else None
-            capital_employed = (assets or 0) - (current_liabilities or 0)
-            roce = self.utils.safe_divide(ebit, capital_employed) if capital_employed > 0 else None
-
-            net_margin = self.utils.safe_divide(net_income, revenue)
-            ebitda_margin = self.utils.safe_divide(ebitda, revenue)
-
-            current_ratio = self.utils.safe_divide(current_assets, current_liabilities)
-            quick_assets = (current_assets or 0) - (inventory or 0) if current_assets is not None and inventory is not None else current_assets
-            quick_ratio = self.utils.safe_divide(quick_assets, current_liabilities)
-            cash_ratio = self.utils.safe_divide(cash, current_liabilities)
-            ocf_to_current_liabilities = self.utils.safe_divide(operating_cash_flow, current_liabilities)
-
-            # Efficiency ratios: prefer cost of revenue for inventory turnover if available
-            cost_of_revenue = info.get("costOfRevenue") or self.extractor.get_financial_item("Cost of Revenue", ["CostOfRevenue"])
-            asset_turnover = self.utils.safe_divide(revenue, assets)
-            inventory_turnover = None
-            if cost_of_revenue is not None and inventory is not None:
-                inventory_turnover = self.utils.safe_divide(cost_of_revenue, inventory)
-            elif revenue is not None and inventory is not None and inventory != 0:
-                inventory_turnover = self.utils.safe_divide(revenue, inventory)  # fallback
-
-            receivables_turnover = None
-            if revenue is not None and accounts_receivable is not None:
-                receivables_turnover = self.utils.safe_divide(revenue, accounts_receivable)
-
-            days_sales_outstanding = None
-            if receivables_turnover and receivables_turnover != 0:
-                days_sales_outstanding = 365.0 / receivables_turnover
-
-            debt_to_equity = self.utils.safe_divide(total_debt, equity)
-            debt_to_assets = self.utils.safe_divide(total_debt, assets)
-            equity_ratio = self.utils.safe_divide(equity, assets)
-            debt_to_capital = None
-            if total_debt is not None and equity is not None:
-                denom = (total_debt + equity)
-                debt_to_capital = self.utils.safe_divide(total_debt, denom) if denom != 0 else None
-
-            interest_coverage = self.utils.safe_divide(ebit, interest_expense)
-
-            fcf_yield = None
-            if free_cash_flow is not None and market_cap:
-                fcf_yield = self.utils.safe_divide(free_cash_flow, market_cap)
-
-            quality_of_earnings = None
-            if operating_cash_flow is not None and net_income is not None and net_income != 0:
-                quality_of_earnings = self.utils.safe_divide(operating_cash_flow, net_income)
-
-            fm = FinancialMetrics(
-                price=price,
-                market_cap=market_cap,
-                shares_outstanding=shares_out,
-                pe_ratio=pe_ratio,
-                pb_ratio=pb_ratio,
-                peg_ratio=peg_ratio,
-                ev_ebitda=ev_ebitda,
-                ps_ratio=ps_ratio,
-                pcf_ratio=pcf_ratio,
-                ev_sales=ev_sales,
-                dividend_yield=dividend_yield,
-                roe=roe,
-                roa=roa,
-                roic=roic,
-                roce=roce,
-                gross_margin=gross_margin,
-                operating_margin=operating_margin,
-                net_margin=net_margin,
-                ebitda_margin=ebitda_margin,
-                current_ratio=current_ratio,
-                quick_ratio=quick_ratio,
-                cash_ratio=cash_ratio,
-                ocf_to_current_liabilities=ocf_to_current_liabilities,
-                asset_turnover=asset_turnover,
-                inventory_turnover=inventory_turnover,
-                receivables_turnover=receivables_turnover,
-                days_sales_outstanding=days_sales_outstanding,
-                debt_to_equity=debt_to_equity,
-                debt_to_assets=debt_to_assets,
-                equity_ratio=equity_ratio,
-                debt_to_capital=debt_to_capital,
-                interest_coverage=interest_coverage,
-                operating_cash_flow=operating_cash_flow,
-                capex=capex,
-                free_cash_flow=free_cash_flow,
-                fcf_yield=fcf_yield,
-                quality_of_earnings=quality_of_earnings,
-                revenue_growth=revenue_growth,
-                earnings_growth=earnings_growth,
-                enterprise_value=enterprise_value,
-                book_value=book_value,
-                eps=eps
-            )
-
-            return fm
-
-        return await loop.run_in_executor(None, _calculate)
-
+        df = df.sort_values(by=sort_by, na_position='last', ignore_index=True)
 
-'''
+    return df