Financial Analysis Agent

"""
Financial Data Collector Module

Handles integration with financial data APIs and collection of stock data,
financial statements, and key metrics.
"""

import yfinance as yf
import pandas as pd
from alpha_vantage.fundamentaldata import FundamentalData
from typing import Dict, List


class FinancialDataCollector:
    """Collects financial data from various APIs."""

    def __init__(self, api_key: str = None):
        """
        Initialize the financial data collector.

        Args:
            api_key: Alpha Vantage API key for fundamental data
        """
        self.stock_data = yf.Ticker
        if api_key:
            self.fundamental_data = FundamentalData(api_key=api_key)
        else:
            self.fundamental_data = None

    def get_stock_data(self, ticker: str, period="1y") -> pd.DataFrame:
        """
        Retrieve stock price data for a given ticker.

        Args:
            ticker: Stock ticker symbol
            period: Time period for data (default: 1 year)

        Returns:
            DataFrame with stock price data
        """
        data = yf.download(ticker, period=period)
        return data

    def get_financial_statements(self, ticker: str) -> Dict:
        """
        Retrieve financial statements for a company.

        Args:
            ticker: Stock ticker symbol

        Returns:
            Dictionary with income statement, balance sheet, and cash flow
        """
        company = yf.Ticker(ticker)
        return {
            "income_statement": company.financials,
            "balance_sheet": company.balance_sheet,
            "cash_flow": company.cashflow
        }

    def get_key_metrics(self, ticker: str) -> Dict:
        """
        Retrieve key financial metrics for a company.

        Args:
            ticker: Stock ticker symbol

        Returns:
            Dictionary with key metrics like market cap, PE ratio, etc.
        """
        company = yf.Ticker(ticker)
        return {
            "market_cap": company.info.get("marketCap"),
            "pe_ratio": company.info.get("trailingPE"),
            "pb_ratio": company.info.get("priceToBook"),
            "dividend_yield": company.info.get("dividendYield"),
            "52_week_high": company.info.get("fiftyTwoWeekHigh"),
            "52_week_low": company.info.get("fiftyTwoWeekLow")
        }

"""
Fundamental Analysis Module

Implements fundamental analysis techniques including profitability ratios,
valuation ratios, and liquidity ratios.
"""

from typing import Dict


class FundamentalAnalyzer:
    """Performs fundamental analysis on financial data."""

    def calculate_profitability_ratios(self, financials: Dict) -> Dict[str, float]:
        """
        Calculate profitability ratios.

        Args:
            financials: Dictionary with financial data

        Returns:
            Dictionary with profitability ratios
        """
        return {
            "gross_margin": (
                financials["revenue"] - financials["cost_of_goods"]
            ) / financials["revenue"],
            "operating_margin": (
                financials["operating_income"] / financials["revenue"]
            ),
            "net_margin": (
                financials["net_income"] / financials["revenue"]
            ),
            "roa": financials["net_income"] / financials["total_assets"],
            "roe": financials["net_income"] / financials["equity"]
        }

    def calculate_valuation_ratios(self, financials: Dict, market_cap: float) -> Dict[str, float]:
        """
        Calculate valuation ratios.

        Args:
            financials: Dictionary with financial data
            market_cap: Current market capitalization

        Returns:
            Dictionary with valuation ratios
        """
        return {
            "pe_ratio": market_cap / financials["net_income"],
            "pb_ratio": market_cap / financials["book_value"],
            "peg_ratio": (market_cap / financials["net_income"]) / (
                financials["earnings_growth_rate"] * 100
            ),
            "price_to_sales": market_cap / financials["revenue"]
        }

    def calculate_liquidity_ratios(self, financials: Dict) -> Dict[str, float]:
        """
        Calculate liquidity ratios.

        Args:
            financials: Dictionary with financial data

        Returns:
            Dictionary with liquidity ratios
        """
        return {
            "current_ratio": (
                financials["current_assets"] / financials["current_liabilities"]
            ),
            "quick_ratio": (
                (financials["current_assets"] - financials["inventory"]) /
                financials["current_liabilities"]
            ),
            "debt_to_equity": (
                financials["total_debt"] / financials["equity"]
            )
        }

"""
Investment Recommendation Module

Generates investment recommendations based on technical and fundamental analysis.
"""

from typing import Dict


class InvestmentRecommender:
    """Generates investment recommendations based on analysis."""

    def generate_recommendation(self, analysis_results: Dict) -> Dict:
        """
        Generate investment recommendation.

        Args:
            analysis_results: Dictionary with analysis results

        Returns:
            Dictionary with recommendation, confidence, reasoning, price target, and risk level
        """
        score = self._calculate_investment_score(analysis_results)

        if score >= 8:
            action = "STRONG BUY"
            reason = analysis_results["bullish_factors"]
        elif score >= 6:
            action = "BUY"
            reason = analysis_results["bullish_factors"]
        elif score >= 4:
            action = "HOLD"
            reason = "Mixed signals"
        elif score >= 2:
            action = "SELL"
            reason = analysis_results["bearish_factors"]
        else:
            action = "STRONG SELL"
            reason = analysis_results["bearish_factors"]

        return {
            "action": action,
            "confidence": score / 10,
            "reasoning": reason,
            "price_target": self._calculate_price_target(analysis_results),
            "risk_level": self._assess_risk_level(analysis_results)
        }

    def _calculate_investment_score(self, results: Dict) -> float:
        """
        Calculate investment score.

        Args:
            results: Analysis results

        Returns:
            Score between 0 and 10
        """
        score = 5  # Start at neutral

        # Technical signals
        if results.get("technical_signal") == "bullish":
            score += 1.5
        elif results.get("technical_signal") == "bearish":
            score -= 1.5

        # Fundamental strength
        if results.get("pe_ratio_attractive"):
            score += 1
        if results.get("strong_cash_flow"):
            score += 1
        if results.get("dividend_growth"):
            score += 0.5

        # Risk factors
        if results.get("high_debt"):
            score -= 1
        if results.get("declining_revenue"):
            score -= 1.5

        return max(0, min(10, score))

    def _calculate_price_target(self, analysis_results: Dict) -> float:
        """
        Calculate price target.

        Args:
            analysis_results: Analysis results

        Returns:
            Estimated price target
        """
        # Placeholder for price target calculation
        return 0.0

    def _assess_risk_level(self, analysis_results: Dict) -> str:
        """
        Assess risk level.

        Args:
            analysis_results: Analysis results

        Returns:
            Risk level (Low, Medium, High)
        """
        # Placeholder for risk assessment
        return "Medium"

"""Market data collection and financial data integration."""

import yfinance as yf
import pandas as pd
from typing import Dict, Any


class FinancialDataCollector:
    """Collects financial data from multiple sources."""

    def __init__(self, alpha_vantage_key: str = None):
        """Initialize the financial data collector.

        Args:
            alpha_vantage_key: API key for Alpha Vantage (optional)
        """
        self.stock_data = yf.Ticker
        self.alpha_vantage_key = alpha_vantage_key
        if alpha_vantage_key:
            from alpha_vantage.fundamentaldata import FundamentalData
            self.fundamental_data = FundamentalData(api_key=alpha_vantage_key)

    def get_stock_data(self, ticker: str, period: str = "1y") -> pd.DataFrame:
        """Retrieve historical stock data.

        Args:
            ticker: Stock ticker symbol
            period: Time period for data (default: 1y)

        Returns:
            DataFrame with historical OHLCV data
        """
        data = yf.download(ticker, period=period)
        return data

    def get_financial_statements(self, ticker: str) -> Dict[str, Any]:
        """Retrieve financial statements for a company.

        Args:
            ticker: Stock ticker symbol

        Returns:
            Dictionary containing income statement, balance sheet, and cash flow
        """
        company = yf.Ticker(ticker)
        return {
            "income_statement": company.financials,
            "balance_sheet": company.balance_sheet,
            "cash_flow": company.cashflow
        }

    def get_key_metrics(self, ticker: str) -> Dict[str, Any]:
        """Retrieve key financial metrics for a company.

        Args:
            ticker: Stock ticker symbol

        Returns:
            Dictionary with key metrics like PE ratio, market cap, etc.
        """
        company = yf.Ticker(ticker)
        return {
            "market_cap": company.info.get("marketCap"),
            "pe_ratio": company.info.get("trailingPE"),
            "pb_ratio": company.info.get("priceToBook"),
            "dividend_yield": company.info.get("dividendYield"),
            "52_week_high": company.info.get("fiftyTwoWeekHigh"),
            "52_week_low": company.info.get("fiftyTwoWeekLow")
        }

"""
Portfolio Management Module

Handles portfolio management operations including calculation of portfolio value,
rebalancing, and risk assessment.
"""

import yfinance as yf
import pandas as pd
import numpy as np
from typing import Dict


class PortfolioManager:
    """Manages investment portfolio operations."""

    def __init__(self, portfolio: Dict[str, float]):
        """
        Initialize portfolio manager.

        Args:
            portfolio: Dictionary with ticker symbols and share counts
        """
        self.portfolio = portfolio

    def calculate_portfolio_value(self) -> float:
        """
        Calculate total portfolio value.

        Returns:
            Total portfolio value in currency units
        """
        total_value = 0
        for ticker, shares in self.portfolio.items():
            price = yf.Ticker(ticker).info.get("currentPrice", 0)
            total_value += price * shares
        return total_value

    def rebalance_portfolio(self, target_allocation: Dict[str, float]) -> Dict[str, float]:
        """
        Calculate rebalancing trades needed.

        Args:
            target_allocation: Target allocation percentages

        Returns:
            Dictionary with ticker symbols and shares to buy/sell
        """
        current_value = self.calculate_portfolio_value()
        rebalancing_trades = {}

        for ticker, target_pct in target_allocation.items():
            target_value = current_value * target_pct
            price = yf.Ticker(ticker).info.get("currentPrice", 0)
            current_value_held = self.portfolio.get(ticker, 0) * price
            shares_needed = (target_value - current_value_held) / price

            if shares_needed != 0:
                rebalancing_trades[ticker] = shares_needed

        return rebalancing_trades

    def calculate_portfolio_risk(self) -> float:
        """
        Calculate portfolio volatility/risk.

        Returns:
            Portfolio volatility
        """
        returns = pd.DataFrame()
        for ticker in self.portfolio.keys():
            data = yf.download(ticker, period="1y")
            returns[ticker] = data["Close"].pct_change()

        covariance = returns.cov()
        weights = np.array(list(self.portfolio.values()))
        portfolio_variance = np.dot(weights, np.dot(covariance, weights))
        portfolio_volatility = np.sqrt(portfolio_variance)

        return portfolio_volatility

"""
Risk Analysis Module

Implements risk assessment techniques including volatility calculation,
Value at Risk (VaR), Sharpe ratio, and company risk assessment.
"""

import pandas as pd
from typing import Dict


class RiskAnalyzer:
    """Performs risk analysis on financial data."""

    def calculate_volatility(self, prices: pd.Series, window: int = 30) -> pd.Series:
        """
        Calculate price volatility.

        Args:
            prices: Series of price data
            window: Window size for volatility calculation (default: 30)

        Returns:
            Series with volatility values
        """
        returns = prices.pct_change()
        volatility = returns.rolling(window=window).std()
        return volatility

    def calculate_value_at_risk(self, returns: pd.Series, confidence_level: float = 0.95) -> float:
        """
        Calculate Value at Risk (VaR).

        Args:
            returns: Series of return data
            confidence_level: Confidence level for VaR (default: 0.95)

        Returns:
            Value at Risk value
        """
        return returns.quantile(1 - confidence_level)

    def calculate_sharpe_ratio(self, returns: pd.Series, risk_free_rate: float = 0.02) -> float:
        """
        Calculate Sharpe Ratio.

        Args:
            returns: Series of return data
            risk_free_rate: Risk-free rate (default: 0.02)

        Returns:
            Sharpe ratio value
        """
        excess_returns = returns - risk_free_rate
        return excess_returns.mean() / excess_returns.std()

    def assess_company_risk(self, company_data: Dict) -> Dict[str, float]:
        """
        Assess overall company risk.

        Args:
            company_data: Dictionary with company data

        Returns:
            Dictionary with risk assessments
        """
        risks = {
            "market_risk": company_data.get("beta", 1),
            "liquidity_risk": 1 / company_data.get("avg_trading_volume", 1),
            "credit_risk": company_data.get("debt_to_equity", 0),
        }
        return risks

"""
Technical Analysis Module

Implements technical analysis techniques for stock price analysis including
moving averages, RSI, and support/resistance level identification.
"""

import pandas as pd
from typing import Dict, List


class TechnicalAnalyzer:
    """Performs technical analysis on price data."""

    def calculate_moving_averages(self, prices: pd.Series, windows: List[int] = None) -> Dict[str, pd.Series]:
        """
        Calculate moving averages for given windows.

        Args:
            prices: Series of price data
            windows: List of window sizes (default: [20, 50, 200])

        Returns:
            Dictionary with moving average series
        """
        if windows is None:
            windows = [20, 50, 200]

        mas = {}
        for window in windows:
            mas[f"ma_{window}"] = prices.rolling(window=window).mean()
        return mas

    def calculate_rsi(self, prices: pd.Series, period: int = 14) -> pd.Series:
        """
        Calculate the Relative Strength Index (RSI).

        Args:
            prices: Series of price data
            period: RSI calculation period (default: 14)

        Returns:
            Series with RSI values
        """
        delta = prices.diff()
        gains = (delta.where(delta > 0, 0)).rolling(window=period).mean()
        losses = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
        rs = gains / losses
        rsi = 100 - (100 / (1 + rs))
        return rsi

    def identify_support_resistance(self, prices: pd.Series) -> tuple:
        """
        Identify support and resistance levels.

        Args:
            prices: Series of price data

        Returns:
            Tuple of (support_levels, resistance_levels)
        """
        resistance_levels = prices.rolling(window=5, center=True).max()
        support_levels = prices.rolling(window=5, center=True).min()
        return support_levels, resistance_levels