FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.
C++ ai-agentsalgorithmic-tradingbloomberg-terminalcppfinancefinancial-marketsfintechgood-first-issueinvestmentinvestment-researchmachine-learningopensourcepythonqtquantitative-financestock-markettrading
📊 Add comprehensive Analytics Engine with standardized documentation
rudrasheth40a8bc1886e7
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/.claude/settings.local.json b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/.claude/settings.local.jsonnew file mode 100644index 000000000..a58f9badc--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/.claude/settings.local.json@@ -0,0 +1,13 @@+{+ "permissions": {+ "allow": [+ "Bash(cat:*)",+ "Bash(git add:*)",+ "Bash(git commit:*)",+ "Bash(find:*)",+ "Bash(python:*)"+ ],+ "deny": [],+ "ask": []+ }+}diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/base_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/base_analytics.pynew file mode 100644index 000000000..465de1da0--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/base_analytics.py@@ -0,0 +1,545 @@+"""+Alternative Investments Base Analytics Module+============================================++Core financial mathematics foundation and abstract base classes for alternative+investment analytics. Provides essential calculations including IRR, NPV, Sharpe+ratios, VaR, and performance metrics compliant with CFA Institute standards+for alternative investment analysis and portfolio management.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Cash flow series for IRR/NPV calculations+ - Historical return data for performance metrics+ - Market data for benchmarking and risk calculations+ - Asset parameters for valuation models+ - Time series data with datetime indexing++OUTPUT:+ - Financial metrics (IRR, NPV, ROI, MOIC, DPI)+ - Risk-adjusted performance measures (Sharpe, Sortino, Calmar ratios)+ - Value-at-Risk and Conditional VaR calculations+ - Performance attribution and benchmark comparisons+ - Portfolio level analytics and aggregations++PARAMETERS:+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - confidence_level: VaR confidence level (default: 0.95)+ - benchmark_period: Benchmark data period in years (default: 3)+ - compounding_frequency: Compounding frequency (default: 'annual')+ - decimal_precision: Decimal precision for calculations (default: 8)+ - currency: Base currency for calculations (default: 'USD')+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Optional, Dict, Any, Tuple, Union+from datetime import datetime, timedelta+from abc import ABC, abstractmethod+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config, ValidationRules+)++logger = logging.getLogger(__name__)+++class FinancialMath:+ """Core financial mathematics functions following CFA standards"""++ @staticmethod+ def irr(cash_flows: List[CashFlow], guess: Decimal = Decimal('0.10')) -> Optional[Decimal]:+ """+ Calculate Internal Rate of Return using Newton-Raphson method+ CFA Standard: IRR is the discount rate that makes NPV = 0++ Args:+ cash_flows: List of CashFlow objects+ guess: Initial guess for IRR++ Returns:+ IRR as decimal (e.g., 0.15 for 15%)+ """+ if not cash_flows:+ return None++ # Sort cash flows by date+ sorted_cfs = sorted(cash_flows, key=lambda x: x.date)++ # Convert to numpy arrays for calculation+ dates = [datetime.strptime(cf.date, '%Y-%m-%d') for cf in sorted_cfs]+ amounts = [float(cf.amount) for cf in sorted_cfs]++ # Calculate days from first cash flow+ base_date = dates[0]+ days = [(d - base_date).days for d in dates]++ def npv(rate):+ return sum(amount / (1 + rate) ** (day / 365.25) for amount, day in zip(amounts, days))++ def npv_derivative(rate):+ return sum(-amount * (day / 365.25) / (1 + rate) ** ((day / 365.25) + 1)+ for amount, day in zip(amounts, days))++ rate = float(guess)+ for _ in range(Config.PE_IRR_MAX_ITERATIONS):+ npv_val = npv(rate)+ if abs(npv_val) < float(Config.PE_IRR_TOLERANCE):+ return Decimal(str(rate))++ npv_deriv = npv_derivative(rate)+ if abs(npv_deriv) < 1e-12:+ break++ rate = rate - npv_val / npv_deriv++ return None # Convergence failed++ @staticmethod+ def npv(cash_flows: List[CashFlow], discount_rate: Decimal) -> Decimal:+ """+ Calculate Net Present Value+ CFA Standard: NPV = Σ(CF_t / (1+r)^t)++ Args:+ cash_flows: List of CashFlow objects+ discount_rate: Discount rate as decimal++ Returns:+ NPV value+ """+ if not cash_flows:+ return Decimal('0')++ sorted_cfs = sorted(cash_flows, key=lambda x: x.date)+ base_date = datetime.strptime(sorted_cfs[0].date, '%Y-%m-%d')++ npv_value = Decimal('0')+ for cf in sorted_cfs:+ cf_date = datetime.strptime(cf.date, '%Y-%m-%d')+ years = Decimal(str((cf_date - base_date).days)) / Constants.DAYS_IN_YEAR+ present_value = cf.amount / ((Decimal('1') + discount_rate) ** years)+ npv_value += present_value++ return npv_value++ @staticmethod+ def moic(cash_flows: List[CashFlow]) -> Optional[Decimal]:+ """+ Calculate Multiple of Invested Capital+ CFA Standard: MOIC = Total Distributions / Total Contributions++ Args:+ cash_flows: List of CashFlow objects++ Returns:+ MOIC as decimal multiple+ """+ total_invested = Decimal('0')+ total_distributed = Decimal('0')++ for cf in cash_flows:+ if cf.amount < 0: # Investment/contribution+ total_invested += abs(cf.amount)+ elif cf.amount > 0: # Distribution+ total_distributed += cf.amount++ if total_invested == 0:+ return None++ return total_distributed / total_invested++ @staticmethod+ def dpi(cash_flows: List[CashFlow]) -> Decimal:+ """+ Calculate Distributions to Paid-In Capital+ CFA Standard: DPI = Cumulative Distributions / Paid-In Capital++ Args:+ cash_flows: List of CashFlow objects++ Returns:+ DPI ratio+ """+ total_paid_in = Decimal('0')+ total_distributions = Decimal('0')++ for cf in cash_flows:+ if cf.cf_type in ['capital_call', 'investment'] or cf.amount < 0:+ total_paid_in += abs(cf.amount)+ elif cf.cf_type == 'distribution' or cf.amount > 0:+ total_distributions += cf.amount++ if total_paid_in == 0:+ return Decimal('0')++ return total_distributions / total_paid_in++ @staticmethod+ def rvpi(cash_flows: List[CashFlow], current_nav: Decimal) -> Decimal:+ """+ Calculate Residual Value to Paid-In Capital+ CFA Standard: RVPI = Net Asset Value / Paid-In Capital++ Args:+ cash_flows: List of CashFlow objects+ current_nav: Current Net Asset Value++ Returns:+ RVPI ratio+ """+ total_paid_in = Decimal('0')++ for cf in cash_flows:+ if cf.cf_type in ['capital_call', 'investment'] or cf.amount < 0:+ total_paid_in += abs(cf.amount)++ if total_paid_in == 0:+ return Decimal('0')++ return current_nav / total_paid_in++ @staticmethod+ def sharpe_ratio(returns: List[Decimal], risk_free_rate: Decimal = None) -> Decimal:+ """+ Calculate Sharpe Ratio+ CFA Standard: (Portfolio Return - Risk-Free Rate) / Portfolio Standard Deviation++ Args:+ returns: List of period returns+ risk_free_rate: Risk-free rate for the period++ Returns:+ Sharpe ratio+ """+ if len(returns) < 2:+ return Decimal('0')++ if risk_free_rate is None:+ risk_free_rate = Config.RISK_FREE_RATE / Constants.MONTHS_IN_YEAR # Monthly rate++ excess_returns = [r - risk_free_rate for r in returns]+ mean_excess = sum(excess_returns) / len(excess_returns)++ if len(excess_returns) == 1:+ return Decimal('0')++ variance = sum((r - mean_excess) ** 2 for r in excess_returns) / (len(excess_returns) - 1)+ std_dev = variance.sqrt()++ if std_dev == 0:+ return Decimal('0')++ return mean_excess / std_dev++ @staticmethod+ def sortino_ratio(returns: List[Decimal], target_return: Decimal = Decimal('0')) -> Decimal:+ """+ Calculate Sortino Ratio+ CFA Standard: (Portfolio Return - Target Return) / Downside Deviation++ Args:+ returns: List of period returns+ target_return: Target or minimum acceptable return++ Returns:+ Sortino ratio+ """+ if len(returns) < 2:+ return Decimal('0')++ excess_returns = [r - target_return for r in returns]+ mean_excess = sum(excess_returns) / len(excess_returns)++ # Calculate downside deviation (only negative excess returns)+ downside_returns = [r for r in excess_returns if r < 0]++ if not downside_returns:+ return Decimal('999') # No downside risk++ downside_variance = sum(r ** 2 for r in downside_returns) / len(returns)+ downside_deviation = downside_variance.sqrt()++ if downside_deviation == 0:+ return Decimal('0')++ return mean_excess / downside_deviation++ @staticmethod+ def maximum_drawdown(prices: List[Decimal]) -> Tuple[Decimal, int, int]:+ """+ Calculate Maximum Drawdown+ CFA Standard: Maximum peak-to-trough decline++ Args:+ prices: List of price values++ Returns:+ Tuple of (max_drawdown, peak_index, trough_index)+ """+ if len(prices) < 2:+ return Decimal('0'), 0, 0++ max_dd = Decimal('0')+ peak_idx = 0+ trough_idx = 0+ current_peak = prices[0]+ current_peak_idx = 0++ for i, price in enumerate(prices):+ if price > current_peak:+ current_peak = price+ current_peak_idx = i++ drawdown = (current_peak - price) / current_peak+ if drawdown > max_dd:+ max_dd = drawdown+ peak_idx = current_peak_idx+ trough_idx = i++ return max_dd, peak_idx, trough_idx++ @staticmethod+ def var_historical(returns: List[Decimal], confidence_level: Decimal = Decimal('0.05')) -> Decimal:+ """+ Calculate Historical Value at Risk+ CFA Standard: Historical simulation method++ Args:+ returns: List of historical returns+ confidence_level: Confidence level (e.g., 0.05 for 95% VaR)++ Returns:+ VaR value (positive number representing loss)+ """+ if not returns:+ return Decimal('0')++ sorted_returns = sorted(returns)+ index = int(len(sorted_returns) * confidence_level)++ if index >= len(sorted_returns):+ index = len(sorted_returns) - 1++ return abs(sorted_returns[index])++ @staticmethod+ def calmar_ratio(annual_return: Decimal, max_drawdown: Decimal) -> Decimal:+ """+ Calculate Calmar Ratio+ CFA Standard: Annual Return / Maximum Drawdown++ Args:+ annual_return: Annualized return+ max_drawdown: Maximum drawdown++ Returns:+ Calmar ratio+ """+ if max_drawdown == 0:+ return Decimal('999') # No drawdown++ return annual_return / max_drawdown+++class AlternativeInvestmentBase(ABC):+ """+ Abstract base class for all alternative investment types+ Defines common interface and shared functionality+ """++ def __init__(self, parameters: AssetParameters):+ self.parameters = parameters+ self.market_data: List[MarketData] = []+ self.cash_flows: List[CashFlow] = []+ self.performance_history: List[Performance] = []+ self.config = Config()+ self.math = FinancialMath()+ self._validate_parameters()++ def _validate_parameters(self) -> None:+ """Validate asset parameters"""+ if self.parameters.management_fee:+ if not ValidationRules.validate_management_fee(+ self.parameters.management_fee,+ self.parameters.asset_class+ ):+ raise ValueError(f"Invalid management fee: {self.parameters.management_fee}")++ if self.parameters.performance_fee:+ if not ValidationRules.validate_performance_fee(+ self.parameters.performance_fee,+ self.parameters.asset_class+ ):+ raise ValueError(f"Invalid performance fee: {self.parameters.performance_fee}")++ def add_market_data(self, data: List[MarketData]) -> None:+ """Add market data to the investment"""+ self.market_data.extend(data)+ self.market_data.sort(key=lambda x: x.timestamp)++ def add_cash_flows(self, cash_flows: List[CashFlow]) -> None:+ """Add cash flows to the investment"""+ self.cash_flows.extend(cash_flows)+ self.cash_flows.sort(key=lambda x: x.date)++ def get_latest_price(self) -> Optional[Decimal]:+ """Get the most recent price"""+ if not self.market_data:+ return None+ return self.market_data[-1].price++ def get_price_history(self, start_date: str = None, end_date: str = None) -> List[MarketData]:+ """Get price history for specified date range"""+ filtered_data = self.market_data++ if start_date:+ filtered_data = [d for d in filtered_data if d.timestamp >= start_date]++ if end_date:+ filtered_data = [d for d in filtered_data if d.timestamp <= end_date]++ return filtered_data++ def calculate_simple_returns(self) -> List[Decimal]:+ """Calculate simple returns from price data"""+ if len(self.market_data) < 2:+ return []++ returns = []+ for i in range(1, len(self.market_data)):+ prev_price = self.market_data[i - 1].price+ curr_price = self.market_data[i].price+ ret = (curr_price - prev_price) / prev_price+ returns.append(ret)++ return returns++ def calculate_log_returns(self) -> List[Decimal]:+ """Calculate logarithmic returns from price data"""+ if len(self.market_data) < 2:+ return []++ returns = []+ for i in range(1, len(self.market_data)):+ prev_price = self.market_data[i - 1].price+ curr_price = self.market_data[i].price+ ret = (curr_price / prev_price).ln()+ returns.append(ret)++ return returns++ def calculate_volatility(self, returns: List[Decimal] = None, annualized: bool = True) -> Decimal:+ """Calculate volatility (standard deviation of returns)"""+ if returns is None:+ returns = self.calculate_simple_returns()++ if len(returns) < 2:+ return Decimal('0')++ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ volatility = variance.sqrt()++ if annualized:+ # Annualize based on frequency (assume daily data)+ volatility *= Constants.BUSINESS_DAYS_IN_YEAR.sqrt()++ return volatility++ def calculate_total_return(self, start_date: str = None, end_date: str = None) -> Decimal:+ """Calculate total return including distributions"""+ price_data = self.get_price_history(start_date, end_date)++ if len(price_data) < 2:+ return Decimal('0')++ # Price appreciation+ start_price = price_data[0].price+ end_price = price_data[-1].price+ price_return = (end_price - start_price) / start_price++ # Add distributions/cash flows+ relevant_cfs = self.cash_flows+ if start_date:+ relevant_cfs = [cf for cf in relevant_cfs if cf.date >= start_date]+ if end_date:+ relevant_cfs = [cf for cf in relevant_cfs if cf.date <= end_date]++ distributions = sum(cf.amount for cf in relevant_cfs if cf.amount > 0)+ distribution_return = distributions / start_price++ return price_return + distribution_return++ def calculate_fees(self, nav: Decimal, period_days: int = 365) -> Dict[str, Decimal]:+ """Calculate management and performance fees"""+ fees = {}++ # Management fee+ if self.parameters.management_fee:+ mgmt_fee = nav * self.parameters.management_fee * (Decimal(str(period_days)) / Constants.DAYS_IN_YEAR)+ fees['management_fee'] = mgmt_fee++ # Performance fee (simplified - would need high water mark tracking)+ if self.parameters.performance_fee:+ # This is a simplified calculation+ returns = self.calculate_simple_returns()+ if returns:+ excess_return = sum(returns) - (self.parameters.hurdle_rate or Decimal('0'))+ if excess_return > 0:+ perf_fee = nav * excess_return * self.parameters.performance_fee+ fees['performance_fee'] = perf_fee++ return fees++ @abstractmethod+ def calculate_nav(self) -> Decimal:+ """Calculate Net Asset Value - must be implemented by subclasses"""+ pass++ @abstractmethod+ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key performance metrics - must be implemented by subclasses"""+ pass++ @abstractmethod+ def valuation_summary(self) -> Dict[str, Any]:+ """Provide valuation summary - must be implemented by subclasses"""+ pass++ def get_performance_summary(self) -> Dict[str, Any]:+ """Get comprehensive performance summary"""+ returns = self.calculate_simple_returns()++ if not returns:+ return {"error": "Insufficient data for performance calculation"}++ volatility = self.calculate_volatility(returns)+ sharpe = self.math.sharpe_ratio(returns)+ sortino = self.math.sortino_ratio(returns)++ prices = [md.price for md in self.market_data]+ max_dd, peak_idx, trough_idx = self.math.maximum_drawdown(prices)++ var_95 = self.math.var_historical(returns, Decimal('0.05'))++ total_return = self.calculate_total_return()++ return {+ 'total_return': float(total_return),+ 'annualized_return': float(total_return * Constants.DAYS_IN_YEAR / len(self.market_data)),+ 'volatility': float(volatility),+ 'sharpe_ratio': float(sharpe),+ 'sortino_ratio': float(sortino),+ 'maximum_drawdown': float(max_dd),+ 'var_95': float(var_95),+ 'number_of_observations': len(returns),+ 'latest_price': float(self.get_latest_price() or 0)+ }+++# Export main components+__all__ = ['FinancialMath', 'AlternativeInvestmentBase']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/config.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/config.pynew file mode 100644index 000000000..c766ea76b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/config.py@@ -0,0 +1,338 @@+"""+Alternative Investments Configuration Module+============================================++Centralized configuration management for alternative investments analytics platform.+Provides constants, validation rules, enums, and parameter settings compliant+with CFA Institute standards for alternative investment analysis across all+asset classes including private equity, real estate, hedge funds, and digital assets.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Configuration files (JSON/YAML) for asset parameters+ - Validation rule definitions for data quality checks+ - Risk parameters and tolerance settings+ - Market data source configurations+ - Currency and exchange rate settings++OUTPUT:+ - Standardized configuration objects+ - Validated parameters for analytics calculations+ - Asset class specific settings and constraints+ - Risk management configuration parameters+ - Data source connection settings++PARAMETERS:+ - default_currency: Base currency for calculations (default: 'USD')+ - decimal_precision: Precision for financial calculations (default: 8)+ - max_lookback_years: Maximum historical data lookback (default: 20)+ - min_data_quality_score: Minimum data quality threshold (default: 0.8)+ - risk_free_rate: Default risk-free rate (default: 0.02)+ - confidence_levels: VaR confidence levels (default: [0.90, 0.95, 0.99])+"""++from decimal import Decimal, getcontext+from typing import Dict, List, Any, Optional+from dataclasses import dataclass+from enum import Enum+import logging++# Set high precision for financial calculations+getcontext().prec = 28+++# ============================================================================+# CALCULATION CONSTANTS+# ============================================================================++class Constants:+ """Mathematical and financial constants"""+ DAYS_IN_YEAR = Decimal('365.25')+ BUSINESS_DAYS_IN_YEAR = Decimal('252')+ MONTHS_IN_YEAR = Decimal('12')+ QUARTERS_IN_YEAR = Decimal('4')+ BASIS_POINTS = Decimal('10000')+ PERCENT = Decimal('100')++ # Risk-free rates (update as needed)+ DEFAULT_RISK_FREE_RATE = Decimal('0.03') # 3%++ # Alternative investment specific+ PE_TYPICAL_FUND_LIFE = 10 # years+ RE_DEPRECIATION_YEARS = 39 # US commercial real estate+ COMMODITY_STORAGE_COST_TYPICAL = Decimal('0.02') # 2%+++# ============================================================================+# ENUMS AND CLASSIFICATIONS+# ============================================================================++class AssetClass(Enum):+ """Alternative investment asset classes"""+ PRIVATE_EQUITY = "private_equity"+ PRIVATE_DEBT = "private_debt"+ REAL_ESTATE = "real_estate"+ REIT = "reit"+ INFRASTRUCTURE = "infrastructure"+ COMMODITIES = "commodities"+ TIMBERLAND = "timberland"+ FARMLAND = "farmland"+ RAW_LAND = "raw_land"+ HEDGE_FUND = "hedge_fund"+ DIGITAL_ASSETS = "digital_assets"+++class InvestmentMethod(Enum):+ """Investment access methods"""+ DIRECT = "direct"+ CO_INVESTMENT = "co_investment"+ FUND = "fund"+++class HedgeFundStrategy(Enum):+ """Hedge fund strategy classifications"""+ # Equity Related+ LONG_SHORT_EQUITY = "long_short_equity"+ EQUITY_MARKET_NEUTRAL = "equity_market_neutral"+ DEDICATED_SHORT_BIAS = "dedicated_short_bias"++ # Event Driven+ MERGER_ARBITRAGE = "merger_arbitrage"+ DISTRESSED_SECURITIES = "distressed_securities"+ ACTIVIST = "activist"+ SPECIAL_SITUATIONS = "special_situations"++ # Relative Value+ FIXED_INCOME_ARBITRAGE = "fixed_income_arbitrage"+ CONVERTIBLE_ARBITRAGE = "convertible_arbitrage"+ ASSET_BACKED_SECURITIES = "asset_backed_securities"+ VOLATILITY_ARBITRAGE = "volatility_arbitrage"++ # Opportunistic+ GLOBAL_MACRO = "global_macro"+ CTA_MANAGED_FUTURES = "cta_managed_futures"++ # Specialist+ REINSURANCE = "reinsurance"+ STRUCTURED_CREDIT = "structured_credit"++ # Multi-Manager+ MULTI_STRATEGY = "multi_strategy"+ FUND_OF_FUNDS = "fund_of_funds"+++class CommoditySector(Enum):+ """Commodity sector classifications"""+ ENERGY = "energy"+ METALS = "metals"+ AGRICULTURE = "agriculture"+ LIVESTOCK = "livestock"+++class RealEstateType(Enum):+ """Real estate property types"""+ OFFICE = "office"+ RETAIL = "retail"+ INDUSTRIAL = "industrial"+ MULTIFAMILY = "multifamily"+ HOTEL = "hotel"+ MIXED_USE = "mixed_use"+ LAND = "land"+++# ============================================================================+# DATA SCHEMAS+# ============================================================================++@dataclass+class AssetParameters:+ """Standard parameters for alternative investments"""+ asset_class: AssetClass+ ticker: Optional[str] = None+ name: Optional[str] = None+ currency: str = "USD"+ inception_date: Optional[str] = None+ management_fee: Optional[Decimal] = None+ performance_fee: Optional[Decimal] = None+ hurdle_rate: Optional[Decimal] = None+ high_water_mark: bool = True+ lock_up_period: Optional[int] = None # months+ redemption_frequency: Optional[str] = None+ minimum_investment: Optional[Decimal] = None+++@dataclass+class MarketData:+ """Standardized market data structure"""+ timestamp: str+ price: Decimal+ volume: Optional[Decimal] = None+ bid: Optional[Decimal] = None+ ask: Optional[Decimal] = None+ high: Optional[Decimal] = None+ low: Optional[Decimal] = None+ open: Optional[Decimal] = None+ close: Optional[Decimal] = None+++@dataclass+class CashFlow:+ """Cash flow data structure"""+ date: str+ amount: Decimal+ cf_type: str # 'inflow', 'outflow', 'distribution', 'capital_call'+ description: Optional[str] = None+++@dataclass+class Performance:+ """Performance metrics structure"""+ period: str+ total_return: Decimal+ annualized_return: Optional[Decimal] = None+ volatility: Optional[Decimal] = None+ sharpe_ratio: Optional[Decimal] = None+ max_drawdown: Optional[Decimal] = None+ benchmark_return: Optional[Decimal] = None+ alpha: Optional[Decimal] = None+ beta: Optional[Decimal] = None+++# ============================================================================+# CONFIGURATION SETTINGS+# ============================================================================++class Config:+ """Main configuration class"""++ # Data validation settings+ PRICE_TOLERANCE = Decimal('0.0001') # 1 basis point+ MAX_LEVERAGE = Decimal('10.0')+ MIN_PRICE = Decimal('0.0001')++ # Performance calculation settings+ ANNUALIZATION_FACTOR = Constants.DAYS_IN_YEAR+ RISK_FREE_RATE = Constants.DEFAULT_RISK_FREE_RATE++ # Alternative investment specific settings+ PE_IRR_TOLERANCE = Decimal('0.000001')+ PE_IRR_MAX_ITERATIONS = 1000++ # Real estate settings+ RE_CAP_RATE_MIN = Decimal('0.01') # 1%+ RE_CAP_RATE_MAX = Decimal('0.20') # 20%++ # Commodity settings+ COMMODITY_ROLL_DAYS = 5 # Days before expiry to roll++ # Hedge fund settings+ HF_HIGH_WATER_MARK_DEFAULT = True+ HF_HURDLE_RATE_DEFAULT = Decimal('0.08') # 8%++ # Digital assets settings+ CRYPTO_VOLATILITY_FLOOR = Decimal('0.10') # 10% minimum volatility++ # Portfolio settings+ MAX_CONCENTRATION = Decimal('0.50') # 50% max in single asset+ MIN_WEIGHT = Decimal('0.001') # 0.1% minimum weight++ # Reporting settings+ DECIMAL_PLACES = 4+ PERCENTAGE_DECIMAL_PLACES = 2++ @classmethod+ def get_asset_defaults(cls, asset_class: AssetClass) -> Dict[str, Any]:+ """Get default parameters for asset class"""+ defaults = {+ AssetClass.PRIVATE_EQUITY: {+ 'management_fee': Decimal('0.02'), # 2%+ 'performance_fee': Decimal('0.20'), # 20%+ 'lock_up_period': 120, # 10 years+ 'minimum_investment': Decimal('1000000') # $1M+ },+ AssetClass.PRIVATE_DEBT: {+ 'management_fee': Decimal('0.015'), # 1.5%+ 'performance_fee': Decimal('0.10'), # 10%+ 'lock_up_period': 60, # 5 years+ 'minimum_investment': Decimal('250000') # $250K+ },+ AssetClass.REAL_ESTATE: {+ 'management_fee': Decimal('0.01'), # 1%+ 'performance_fee': Decimal('0.15'), # 15%+ 'minimum_investment': Decimal('50000') # $50K+ },+ AssetClass.HEDGE_FUND: {+ 'management_fee': Decimal('0.02'), # 2%+ 'performance_fee': Decimal('0.20'), # 20%+ 'hurdle_rate': Decimal('0.08'), # 8%+ 'high_water_mark': True,+ 'minimum_investment': Decimal('100000') # $100K+ },+ AssetClass.COMMODITIES: {+ 'management_fee': Decimal('0.005'), # 0.5%+ 'minimum_investment': Decimal('10000') # $10K+ },+ AssetClass.DIGITAL_ASSETS: {+ 'management_fee': Decimal('0.01'), # 1%+ 'minimum_investment': Decimal('1000') # $1K+ }+ }+ return defaults.get(asset_class, {})+++# ============================================================================+# LOGGING CONFIGURATION+# ============================================================================++def setup_logging(level: str = "INFO") -> logging.Logger:+ """Setup logging for the analytics module"""+ logging.basicConfig(+ level=getattr(logging, level.upper()),+ format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',+ datefmt='%Y-%m-%d %H:%M:%S'+ )++ logger = logging.getLogger('alternative_investments')+ return logger+++# ============================================================================+# VALIDATION RULES+# ============================================================================++class ValidationRules:+ """Validation rules for different asset classes"""++ @staticmethod+ def validate_performance_fee(fee: Decimal, asset_class: AssetClass) -> bool:+ """Validate performance fee ranges"""+ if asset_class == AssetClass.PRIVATE_EQUITY:+ return Decimal('0.15') <= fee <= Decimal('0.30') # 15-30%+ elif asset_class == AssetClass.HEDGE_FUND:+ return Decimal('0.10') <= fee <= Decimal('0.50') # 10-50%+ elif asset_class == AssetClass.REAL_ESTATE:+ return Decimal('0.05') <= fee <= Decimal('0.25') # 5-25%+ return True++ @staticmethod+ def validate_management_fee(fee: Decimal, asset_class: AssetClass) -> bool:+ """Validate management fee ranges"""+ return Decimal('0.001') <= fee <= Decimal('0.05') # 0.1-5%++ @staticmethod+ def validate_return(return_value: Decimal) -> bool:+ """Validate return values"""+ return Decimal('-0.99') <= return_value <= Decimal('10.0') # -99% to 1000%++ @staticmethod+ def validate_volatility(vol: Decimal) -> bool:+ """Validate volatility values"""+ return Decimal('0.001') <= vol <= Decimal('5.0') # 0.1% to 500%+++# Export main components+__all__ = [+ 'Constants', 'AssetClass', 'InvestmentMethod', 'HedgeFundStrategy',+ 'CommoditySector', 'RealEstateType', 'AssetParameters', 'MarketData',+ 'CashFlow', 'Performance', 'Config', 'ValidationRules', 'setup_logging'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/data_handler.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/data_handler.pynew file mode 100644index 000000000..6131281f0--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/data_handler.py@@ -0,0 +1,471 @@+"""+Alternative Investments Data Handler Module+============================================++Multi-source data ingestion and standardization platform for alternative investments.+Handles data validation, quality assessment, and transformation from various formats+including CSV, JSON, and API sources. Ensures CFA Institute compliance for data+integrity and processing across private equity, hedge funds, real estate, and digital assets.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Market data files (CSV, JSON, Excel) from multiple providers+ - Alternative investment fund performance data+ - Private equity/hedge fund cash flow statements+ - Real estate valuation and income data+ - Digital asset blockchain data and exchange feeds+ - Economic indicators and benchmark data++OUTPUT:+ - Validated and standardized pandas DataFrames+ - Data quality reports and anomaly detection+ - Cleaned time series with consistent formatting+ - Performance metrics and attribution data+ - Portfolio holdings and transaction records++PARAMETERS:+ - data_quality_threshold: Minimum data quality score (default: 0.85)+ - max_missing_percentage: Maximum allowed missing data (default: 0.15)+ - validation_rules: Data validation rule sets (default: strict)+ - currency_base: Base currency for conversion (default: 'USD')+ - frequency: Data frequency standardization (default: 'monthly')+ - outlier_detection: Outlier detection method (default: 'iqr')+"""++import pandas as pd+import numpy as np+from decimal import Decimal, InvalidOperation+from typing import Dict, List, Optional, Union, Any, Tuple+from datetime import datetime, date+import json+import csv+from dataclasses import asdict+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Config, ValidationRules, Constants+)++logger = logging.getLogger(__name__)+++class DataValidationError(Exception):+ """Custom exception for data validation errors"""+ pass+++class DataHandler:+ """+ Centralized data handler for all alternative investment data sources+ Supports multiple input formats and validates according to CFA standards+ """++ def __init__(self):+ self.config = Config()+ self.validation_rules = ValidationRules()++ def standardize_price_data(self, data: Union[Dict, pd.DataFrame, List]) -> List[MarketData]:+ """+ Standardize price data from various sources into MarketData objects++ Args:+ data: Price data in various formats++ Returns:+ List of MarketData objects+ """+ try:+ if isinstance(data, pd.DataFrame):+ return self._from_dataframe(data)+ elif isinstance(data, dict):+ return self._from_dict(data)+ elif isinstance(data, list):+ return self._from_list(data)+ else:+ raise DataValidationError(f"Unsupported data type: {type(data)}")++ except Exception as e:+ logger.error(f"Error standardizing price data: {str(e)}")+ raise DataValidationError(f"Failed to standardize price data: {str(e)}")++ def _from_dataframe(self, df: pd.DataFrame) -> List[MarketData]:+ """Convert DataFrame to MarketData objects"""+ required_columns = ['timestamp', 'price']+ if not all(col in df.columns for col in required_columns):+ raise DataValidationError(f"DataFrame must contain columns: {required_columns}")++ market_data = []+ for _, row in df.iterrows():+ md = MarketData(+ timestamp=self._standardize_timestamp(row['timestamp']),+ price=self._to_decimal(row['price']),+ volume=self._to_decimal(row.get('volume')),+ bid=self._to_decimal(row.get('bid')),+ ask=self._to_decimal(row.get('ask')),+ high=self._to_decimal(row.get('high')),+ low=self._to_decimal(row.get('low')),+ open=self._to_decimal(row.get('open')),+ close=self._to_decimal(row.get('close'))+ )+ self._validate_market_data(md)+ market_data.append(md)++ return market_data++ def _from_dict(self, data: Dict) -> List[MarketData]:+ """Convert dictionary to MarketData objects"""+ if 'data' in data:+ data = data['data']++ if isinstance(data, list):+ return [self._dict_to_market_data(item) for item in data]+ else:+ return [self._dict_to_market_data(data)]++ def _from_list(self, data: List) -> List[MarketData]:+ """Convert list to MarketData objects"""+ return [self._dict_to_market_data(item) for item in data]++ def _dict_to_market_data(self, item: Dict) -> MarketData:+ """Convert single dictionary item to MarketData"""+ md = MarketData(+ timestamp=self._standardize_timestamp(item.get('timestamp', item.get('date', item.get('time')))),+ price=self._to_decimal(item.get('price', item.get('close'))),+ volume=self._to_decimal(item.get('volume')),+ bid=self._to_decimal(item.get('bid')),+ ask=self._to_decimal(item.get('ask')),+ high=self._to_decimal(item.get('high')),+ low=self._to_decimal(item.get('low')),+ open=self._to_decimal(item.get('open')),+ close=self._to_decimal(item.get('close'))+ )+ self._validate_market_data(md)+ return md++ def standardize_cash_flows(self, data: Union[Dict, pd.DataFrame, List]) -> List[CashFlow]:+ """+ Standardize cash flow data for IRR and performance calculations++ Args:+ data: Cash flow data in various formats++ Returns:+ List of CashFlow objects+ """+ try:+ if isinstance(data, pd.DataFrame):+ return self._cash_flows_from_dataframe(data)+ elif isinstance(data, dict):+ return self._cash_flows_from_dict(data)+ elif isinstance(data, list):+ return self._cash_flows_from_list(data)+ else:+ raise DataValidationError(f"Unsupported cash flow data type: {type(data)}")++ except Exception as e:+ logger.error(f"Error standardizing cash flows: {str(e)}")+ raise DataValidationError(f"Failed to standardize cash flows: {str(e)}")++ def _cash_flows_from_dataframe(self, df: pd.DataFrame) -> List[CashFlow]:+ """Convert DataFrame to CashFlow objects"""+ required_columns = ['date', 'amount']+ if not all(col in df.columns for col in required_columns):+ raise DataValidationError(f"Cash flow DataFrame must contain columns: {required_columns}")++ cash_flows = []+ for _, row in df.iterrows():+ cf = CashFlow(+ date=self._standardize_date(row['date']),+ amount=self._to_decimal(row['amount']),+ cf_type=row.get('type', 'inflow' if float(row['amount']) > 0 else 'outflow'),+ description=row.get('description')+ )+ self._validate_cash_flow(cf)+ cash_flows.append(cf)++ return sorted(cash_flows, key=lambda x: x.date)++ def _cash_flows_from_dict(self, data: Dict) -> List[CashFlow]:+ """Convert dictionary to CashFlow objects"""+ if 'cash_flows' in data:+ data = data['cash_flows']++ if isinstance(data, list):+ return [self._dict_to_cash_flow(item) for item in data]+ else:+ return [self._dict_to_cash_flow(data)]++ def _cash_flows_from_list(self, data: List) -> List[CashFlow]:+ """Convert list to CashFlow objects"""+ return [self._dict_to_cash_flow(item) for item in data]++ def _dict_to_cash_flow(self, item: Dict) -> CashFlow:+ """Convert single dictionary item to CashFlow"""+ cf = CashFlow(+ date=self._standardize_date(item.get('date', item.get('timestamp'))),+ amount=self._to_decimal(item.get('amount', item.get('value'))),+ cf_type=item.get('type', item.get('cf_type', 'inflow' if float(item.get('amount', 0)) > 0 else 'outflow')),+ description=item.get('description', item.get('desc'))+ )+ self._validate_cash_flow(cf)+ return cf++ def load_from_csv(self, file_path: str, data_type: str = 'price') -> Union[List[MarketData], List[CashFlow]]:+ """+ Load data from CSV file++ Args:+ file_path: Path to CSV file+ data_type: 'price' or 'cash_flow'++ Returns:+ Standardized data objects+ """+ try:+ df = pd.read_csv(file_path)++ if data_type == 'price':+ return self.standardize_price_data(df)+ elif data_type == 'cash_flow':+ return self.standardize_cash_flows(df)+ else:+ raise DataValidationError(f"Unsupported data type: {data_type}")++ except Exception as e:+ logger.error(f"Error loading CSV file {file_path}: {str(e)}")+ raise DataValidationError(f"Failed to load CSV: {str(e)}")++ def load_from_json(self, file_path: str, data_type: str = 'price') -> Union[List[MarketData], List[CashFlow]]:+ """+ Load data from JSON file++ Args:+ file_path: Path to JSON file+ data_type: 'price' or 'cash_flow'++ Returns:+ Standardized data objects+ """+ try:+ with open(file_path, 'r') as f:+ data = json.load(f)++ if data_type == 'price':+ return self.standardize_price_data(data)+ elif data_type == 'cash_flow':+ return self.standardize_cash_flows(data)+ else:+ raise DataValidationError(f"Unsupported data type: {data_type}")++ except Exception as e:+ logger.error(f"Error loading JSON file {file_path}: {str(e)}")+ raise DataValidationError(f"Failed to load JSON: {str(e)}")++ def calculate_returns(self, prices: List[MarketData], method: str = 'simple') -> pd.DataFrame:+ """+ Calculate returns from price data++ Args:+ prices: List of MarketData objects+ method: 'simple', 'log', or 'compound'++ Returns:+ DataFrame with returns+ """+ if len(prices) < 2:+ raise DataValidationError("Need at least 2 price points to calculate returns")++ # Convert to DataFrame+ df = pd.DataFrame([{+ 'timestamp': p.timestamp,+ 'price': float(p.price)+ } for p in prices])++ df = df.sort_values('timestamp')+ df['timestamp'] = pd.to_datetime(df['timestamp'])++ if method == 'simple':+ df['return'] = df['price'].pct_change()+ elif method == 'log':+ df['return'] = np.log(df['price'] / df['price'].shift(1))+ elif method == 'compound':+ df['return'] = (df['price'] / df['price'].shift(1)) - 1+ else:+ raise DataValidationError(f"Unsupported return calculation method: {method}")++ return df.dropna()++ def aggregate_to_frequency(self, data: List[MarketData], frequency: str = 'monthly') -> List[MarketData]:+ """+ Aggregate data to specified frequency++ Args:+ data: List of MarketData objects+ frequency: 'daily', 'weekly', 'monthly', 'quarterly', 'yearly'++ Returns:+ Aggregated MarketData objects+ """+ if not data:+ return []++ # Convert to DataFrame+ df = pd.DataFrame([{+ 'timestamp': pd.to_datetime(d.timestamp),+ 'price': float(d.price),+ 'volume': float(d.volume) if d.volume else 0,+ 'high': float(d.high) if d.high else float(d.price),+ 'low': float(d.low) if d.low else float(d.price),+ 'open': float(d.open) if d.open else float(d.price),+ 'close': float(d.close) if d.close else float(d.price)+ } for d in data])++ df = df.set_index('timestamp').sort_index()++ # Aggregate based on frequency+ freq_map = {+ 'daily': 'D',+ 'weekly': 'W',+ 'monthly': 'M',+ 'quarterly': 'Q',+ 'yearly': 'Y'+ }++ if frequency not in freq_map:+ raise DataValidationError(f"Unsupported frequency: {frequency}")++ agg_df = df.resample(freq_map[frequency]).agg({+ 'price': 'last',+ 'volume': 'sum',+ 'high': 'max',+ 'low': 'min',+ 'open': 'first',+ 'close': 'last'+ }).dropna()++ # Convert back to MarketData objects+ result = []+ for timestamp, row in agg_df.iterrows():+ md = MarketData(+ timestamp=timestamp.strftime('%Y-%m-%d'),+ price=Decimal(str(row['price'])),+ volume=Decimal(str(row['volume'])) if row['volume'] > 0 else None,+ high=Decimal(str(row['high'])),+ low=Decimal(str(row['low'])),+ open=Decimal(str(row['open'])),+ close=Decimal(str(row['close']))+ )+ result.append(md)++ return result++ def _to_decimal(self, value: Any) -> Optional[Decimal]:+ """Convert value to Decimal with validation"""+ if value is None or pd.isna(value):+ return None++ try:+ decimal_value = Decimal(str(value))+ if decimal_value < self.config.MIN_PRICE and decimal_value != 0:+ raise DataValidationError(f"Price too small: {decimal_value}")+ return decimal_value+ except (InvalidOperation, ValueError) as e:+ raise DataValidationError(f"Invalid decimal value: {value}")++ def _standardize_timestamp(self, timestamp: Any) -> str:+ """Standardize timestamp to ISO format"""+ if isinstance(timestamp, str):+ try:+ dt = pd.to_datetime(timestamp)+ return dt.strftime('%Y-%m-%d %H:%M:%S')+ except:+ return timestamp+ elif isinstance(timestamp, (datetime, date)):+ return timestamp.strftime('%Y-%m-%d %H:%M:%S')+ else:+ return str(timestamp)++ def _standardize_date(self, date_value: Any) -> str:+ """Standardize date to ISO format"""+ if isinstance(date_value, str):+ try:+ dt = pd.to_datetime(date_value)+ return dt.strftime('%Y-%m-%d')+ except:+ return date_value+ elif isinstance(date_value, (datetime, date)):+ return date_value.strftime('%Y-%m-%d')+ else:+ return str(date_value)++ def _validate_market_data(self, md: MarketData) -> None:+ """Validate MarketData object"""+ if md.price <= 0:+ raise DataValidationError(f"Invalid price: {md.price}")++ if md.volume is not None and md.volume < 0:+ raise DataValidationError(f"Invalid volume: {md.volume}")++ # Validate price relationships+ if md.high and md.low and md.high < md.low:+ raise DataValidationError(f"High price ({md.high}) less than low price ({md.low})")++ if md.bid and md.ask and md.bid > md.ask:+ raise DataValidationError(f"Bid price ({md.bid}) greater than ask price ({md.ask})")++ def _validate_cash_flow(self, cf: CashFlow) -> None:+ """Validate CashFlow object"""+ if cf.amount == 0:+ logger.warning(f"Zero cash flow amount on {cf.date}")++ valid_types = ['inflow', 'outflow', 'distribution', 'capital_call', 'dividend', 'interest']+ if cf.cf_type not in valid_types:+ logger.warning(f"Unknown cash flow type: {cf.cf_type}")++ def get_data_summary(self, data: Union[List[MarketData], List[CashFlow]]) -> Dict[str, Any]:+ """Get summary statistics of the data"""+ if not data:+ return {"error": "No data provided"}++ if isinstance(data[0], MarketData):+ prices = [float(d.price) for d in data]+ return {+ "data_type": "MarketData",+ "count": len(data),+ "price_stats": {+ "mean": np.mean(prices),+ "std": np.std(prices),+ "min": np.min(prices),+ "max": np.max(prices)+ },+ "date_range": {+ "start": min(d.timestamp for d in data),+ "end": max(d.timestamp for d in data)+ }+ }+ elif isinstance(data[0], CashFlow):+ amounts = [float(d.amount) for d in data]+ return {+ "data_type": "CashFlow",+ "count": len(data),+ "amount_stats": {+ "total": sum(amounts),+ "mean": np.mean(amounts),+ "std": np.std(amounts),+ "min": np.min(amounts),+ "max": np.max(amounts)+ },+ "date_range": {+ "start": min(d.date for d in data),+ "end": max(d.date for d in data)+ },+ "inflows": sum(1 for d in data if d.amount > 0),+ "outflows": sum(1 for d in data if d.amount < 0)+ }++ return {"error": "Unknown data type"}+++# Export main components+__all__ = ['DataHandler', 'DataValidationError']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/digital_assets.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/digital_assets.pynew file mode 100644index 000000000..984f504e6--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/digital_assets.py@@ -0,0 +1,635 @@+"""+Digital Assets Analytics Module+===============================++Comprehensive analysis framework for digital assets including cryptocurrencies, blockchain tokens, DeFi protocols, and NFTs. Provides valuation methodologies, risk assessment, and portfolio integration analysis for digital asset investments.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Market price data for digital assets (historical prices, volume)+ - Market capitalization and circulating supply data+ - Protocol revenue and metrics for DeFi tokens+ - Staking yields and reward rates for PoS tokens+ - Blockchain network metrics and transaction data++OUTPUT:+ - Digital asset valuation metrics and price analysis+ - Volatility and risk assessment reports+ - Correlation analysis with traditional assets+ - Portfolio integration impact analysis+ - DeFi protocol fundamentals evaluation++PARAMETERS:+ - asset_type: Type of digital asset (cryptocurrency, defi_token, nft, stablecoin)+ - blockchain: Blockchain network (bitcoin, ethereum, etc.) - default: bitcoin+ - market_cap: Current market capitalization+ - circulating_supply: Current circulating supply+ - total_supply: Maximum or total supply+ - trading_volume_24h: 24-hour trading volume+ - staking_yield: Annual staking yield for PoS tokens+ - protocol_revenue: Annual protocol revenue for DeFi tokens+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class DigitalAssetAnalyzer(AlternativeInvestmentBase):+ """+ Digital Asset investment analysis and valuation+ CFA Standards: Risk assessment, correlation analysis, portfolio integration+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.asset_type = getattr(parameters, 'asset_type',+ 'cryptocurrency') # cryptocurrency, defi_token, nft, stablecoin+ self.blockchain = getattr(parameters, 'blockchain', 'bitcoin')+ self.market_cap = getattr(parameters, 'market_cap', None)+ self.circulating_supply = getattr(parameters, 'circulating_supply', None)+ self.total_supply = getattr(parameters, 'total_supply', None)+ self.trading_volume_24h = getattr(parameters, 'trading_volume_24h', None)+ self.staking_yield = getattr(parameters, 'staking_yield', None) # For PoS tokens+ self.protocol_revenue = getattr(parameters, 'protocol_revenue', None) # For DeFi tokens++ def fundamental_metrics(self) -> Dict[str, Any]:+ """+ Calculate fundamental valuation metrics for digital assets+ CFA Standard: Fundamental analysis adaptation for digital assets+ """+ metrics = {}++ # Basic metrics+ if self.market_cap and self.circulating_supply:+ price_per_token = self.market_cap / self.circulating_supply+ metrics['price_per_token'] = float(price_per_token)+ metrics['market_cap'] = float(self.market_cap)+ metrics['circulating_supply'] = float(self.circulating_supply)++ # Supply metrics+ if self.total_supply and self.circulating_supply:+ inflation_rate = (self.total_supply - self.circulating_supply) / self.circulating_supply+ metrics['potential_inflation'] = float(inflation_rate)++ # Liquidity metrics+ if self.trading_volume_24h and self.market_cap:+ volume_to_mcap = self.trading_volume_24h / self.market_cap+ metrics['volume_to_market_cap'] = float(volume_to_mcap)++ # Liquidity classification+ if volume_to_mcap > Decimal('0.1'):+ liquidity_tier = "high"+ elif volume_to_mcap > Decimal('0.01'):+ liquidity_tier = "medium"+ else:+ liquidity_tier = "low"+ metrics['liquidity_tier'] = liquidity_tier++ # Yield metrics for staking tokens+ if self.staking_yield:+ metrics['staking_yield_annual'] = float(self.staking_yield)++ # Risk-adjusted staking yield+ crypto_vol = self.config.CRYPTO_VOLATILITY_FLOOR+ if self.market_data:+ returns = self.calculate_simple_returns()+ if returns:+ actual_vol = self.calculate_volatility(returns)+ crypto_vol = max(actual_vol, crypto_vol)++ risk_adjusted_yield = self.staking_yield / crypto_vol+ metrics['risk_adjusted_staking_yield'] = float(risk_adjusted_yield)++ # Protocol metrics for DeFi tokens+ if self.protocol_revenue and self.market_cap:+ revenue_multiple = self.market_cap / self.protocol_revenue+ metrics['price_to_protocol_revenue'] = float(revenue_multiple)++ return metrics++ def volatility_analysis(self) -> Dict[str, Any]:+ """+ Comprehensive volatility analysis for digital assets+ CFA Standard: Risk measurement adapted for high volatility assets+ """+ returns = self.calculate_simple_returns()++ if not returns:+ return {"error": "Insufficient price data for volatility analysis"}++ analysis = {}++ # Basic volatility metrics+ daily_vol = self.calculate_volatility(returns, annualized=False)+ annualized_vol = daily_vol * Constants.DAYS_IN_YEAR.sqrt()++ analysis['daily_volatility'] = float(daily_vol)+ analysis['annualized_volatility'] = float(annualized_vol)++ # Volatility percentiles+ return_magnitudes = [abs(r) for r in returns]+ sorted_magnitudes = sorted(return_magnitudes)++ if len(sorted_magnitudes) >= 10:+ p90_vol = sorted_magnitudes[int(0.9 * len(sorted_magnitudes))]+ p95_vol = sorted_magnitudes[int(0.95 * len(sorted_magnitudes))]+ p99_vol = sorted_magnitudes[int(0.99 * len(sorted_magnitudes))]++ analysis['90th_percentile_move'] = float(p90_vol)+ analysis['95th_percentile_move'] = float(p95_vol)+ analysis['99th_percentile_move'] = float(p99_vol)++ # Volatility clustering analysis+ vol_clustering = self._detect_volatility_clustering(returns)+ analysis['volatility_clustering'] = vol_clustering++ # Compare to traditional assets+ traditional_equity_vol = Decimal('0.16') # 16% typical equity volatility+ vol_multiple = annualized_vol / traditional_equity_vol+ analysis['volatility_vs_equity'] = float(vol_multiple)++ return analysis++ def _detect_volatility_clustering(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Detect volatility clustering patterns"""+ if len(returns) < 20:+ return {"insufficient_data": True}++ # Calculate rolling volatility+ window = min(10, len(returns) // 4)+ rolling_vols = []++ for i in range(window, len(returns)):+ window_returns = returns[i - window:i]+ window_vol = self.calculate_volatility(window_returns, annualized=False)+ rolling_vols.append(window_vol)++ if len(rolling_vols) < 2:+ return {"insufficient_data": True}++ # Measure persistence in volatility+ vol_changes = []+ for i in range(1, len(rolling_vols)):+ vol_change = (rolling_vols[i] - rolling_vols[i - 1]) / rolling_vols[i - 1]+ vol_changes.append(vol_change)++ # High volatility tends to be followed by high volatility+ clustering_score = len([v for v in vol_changes if abs(v) < Decimal('0.1')]) / len(vol_changes)++ return {+ "clustering_score": float(clustering_score),+ "interpretation": "High" if clustering_score > 0.6 else "Medium" if clustering_score > 0.4 else "Low"+ }++ def correlation_analysis(self, benchmark_returns: List[Decimal],+ traditional_assets: Dict[str, List[Decimal]] = None) -> Dict[str, Any]:+ """+ Analyze correlations with traditional assets and crypto market+ CFA Standard: Diversification benefit analysis+ """+ crypto_returns = self.calculate_simple_returns()++ if not crypto_returns or not benchmark_returns:+ return {"error": "Insufficient return data"}++ if len(crypto_returns) != len(benchmark_returns):+ return {"error": "Return series length mismatch"}++ analysis = {}++ # Correlation with crypto market benchmark+ crypto_correlation = self._calculate_correlation(crypto_returns, benchmark_returns)+ analysis['crypto_market_correlation'] = float(crypto_correlation)++ # Beta relative to crypto market+ crypto_beta = self._calculate_beta(crypto_returns, benchmark_returns)+ analysis['crypto_market_beta'] = float(crypto_beta)++ # Correlation with traditional assets+ if traditional_assets:+ traditional_correlations = {}++ for asset_name, asset_returns in traditional_assets.items():+ if len(asset_returns) == len(crypto_returns):+ correlation = self._calculate_correlation(crypto_returns, asset_returns)+ traditional_correlations[asset_name] = float(correlation)++ analysis['traditional_asset_correlations'] = traditional_correlations++ # Average correlation with traditional assets+ if traditional_correlations:+ avg_traditional_corr = sum(traditional_correlations.values()) / len(traditional_correlations)+ analysis['average_traditional_correlation'] = avg_traditional_corr++ # Diversification benefit assessment+ if avg_traditional_corr < 0.3:+ diversification_benefit = "High"+ elif avg_traditional_corr < 0.6:+ diversification_benefit = "Medium"+ else:+ diversification_benefit = "Low"++ analysis['diversification_benefit'] = diversification_benefit++ return analysis++ def _calculate_correlation(self, returns1: List[Decimal], returns2: List[Decimal]) -> Decimal:+ """Calculate correlation coefficient between two return series"""+ if len(returns1) != len(returns2) or len(returns1) < 2:+ return Decimal('0')++ mean1 = sum(returns1) / len(returns1)+ mean2 = sum(returns2) / len(returns2)++ numerator = sum((r1 - mean1) * (r2 - mean2) for r1, r2 in zip(returns1, returns2))++ sum_sq1 = sum((r1 - mean1) ** 2 for r1 in returns1)+ sum_sq2 = sum((r2 - mean2) ** 2 for r2 in returns2)++ denominator = (sum_sq1 * sum_sq2).sqrt()++ if denominator == 0:+ return Decimal('0')++ return numerator / denominator++ def _calculate_beta(self, asset_returns: List[Decimal], market_returns: List[Decimal]) -> Decimal:+ """Calculate beta relative to market"""+ if len(asset_returns) != len(market_returns) or len(asset_returns) < 2:+ return Decimal('1')++ asset_mean = sum(asset_returns) / len(asset_returns)+ market_mean = sum(market_returns) / len(market_returns)++ covariance = sum((a - asset_mean) * (m - market_mean)+ for a, m in zip(asset_returns, market_returns)) / (len(asset_returns) - 1)++ market_variance = sum((m - market_mean) ** 2 for m in market_returns) / (len(market_returns) - 1)++ if market_variance == 0:+ return Decimal('1')++ return Decimal(str(covariance)) / Decimal(str(market_variance))++ def defi_protocol_analysis(self) -> Dict[str, Any]:+ """+ Analyze DeFi protocol fundamentals+ CFA Standard: Business model analysis for DeFi protocols+ """+ if self.asset_type != 'defi_token':+ return {"not_applicable": "Analysis specific to DeFi tokens"}++ analysis = {}++ # Protocol revenue analysis+ if self.protocol_revenue and self.market_cap:+ # Price-to-Revenue ratio+ p_revenue = self.market_cap / self.protocol_revenue+ analysis['price_to_revenue'] = float(p_revenue)++ # Revenue yield+ revenue_yield = self.protocol_revenue / self.market_cap+ analysis['revenue_yield'] = float(revenue_yield)++ # Token utility assessment+ utility_factors = {+ 'governance_rights': True, # Assumed for most DeFi tokens+ 'fee_discounts': None, # Would need specific protocol data+ 'staking_rewards': self.staking_yield is not None,+ 'protocol_fees_capture': self.protocol_revenue is not None+ }++ analysis['token_utility'] = utility_factors++ # Utility score (simplified)+ utility_score = sum(1 for v in utility_factors.values() if v is True)+ analysis['utility_score'] = utility_score+ analysis['max_utility_score'] = len(utility_factors)++ return analysis++ def risk_assessment(self) -> Dict[str, Any]:+ """+ Comprehensive risk assessment for digital assets+ CFA Standard: Risk identification and measurement+ """+ risk_assessment = {}++ # Technology risk+ risk_assessment['technology_risk'] = {+ 'smart_contract_risk': self.asset_type in ['defi_token'],+ 'blockchain_risk': self.blockchain,+ 'upgrade_risk': True # Most protocols have upgrade mechanisms+ }++ # Regulatory risk+ risk_assessment['regulatory_risk'] = {+ 'classification_uncertainty': True, # Ongoing regulatory developments+ 'geographic_restrictions': 'varies_by_jurisdiction',+ 'compliance_requirements': 'evolving'+ }++ # Market risk+ returns = self.calculate_simple_returns()+ if returns:+ vol_analysis = self.volatility_analysis()++ # Risk tier based on volatility+ if 'annualized_volatility' in vol_analysis:+ annual_vol = vol_analysis['annualized_volatility']+ if annual_vol > 1.0: # >100%+ risk_tier = "Very High"+ elif annual_vol > 0.5: # >50%+ risk_tier = "High"+ elif annual_vol > 0.3: # >30%+ risk_tier = "Medium-High"+ else:+ risk_tier = "Medium"++ risk_assessment['market_risk_tier'] = risk_tier++ # Liquidity risk+ if self.trading_volume_24h and self.market_cap:+ volume_ratio = self.trading_volume_24h / self.market_cap++ if volume_ratio < Decimal('0.001'): # <0.1%+ liquidity_risk = "High"+ elif volume_ratio < Decimal('0.01'): # <1%+ liquidity_risk = "Medium"+ else:+ liquidity_risk = "Low"++ risk_assessment['liquidity_risk'] = liquidity_risk++ # Concentration risk+ if self.circulating_supply and self.total_supply:+ supply_concentration = (self.total_supply - self.circulating_supply) / self.total_supply+ risk_assessment['supply_concentration_risk'] = float(supply_concentration)++ return risk_assessment++ def portfolio_integration_analysis(self, portfolio_returns: List[Decimal],+ target_allocation: Decimal = Decimal('0.05')) -> Dict[str, Any]:+ """+ Analyze impact of adding digital asset to traditional portfolio+ CFA Standard: Portfolio optimization with alternative assets+ """+ crypto_returns = self.calculate_simple_returns()++ if not crypto_returns or not portfolio_returns:+ return {"error": "Insufficient return data"}++ if len(crypto_returns) != len(portfolio_returns):+ return {"error": "Return series length mismatch"}++ integration_analysis = {}++ # Correlation with existing portfolio+ portfolio_correlation = self._calculate_correlation(crypto_returns, portfolio_returns)+ integration_analysis['portfolio_correlation'] = float(portfolio_correlation)++ # Expected portfolio metrics with crypto allocation+ crypto_weight = target_allocation+ portfolio_weight = Decimal('1') - crypto_weight++ # Expected returns+ crypto_mean = sum(crypto_returns) / len(crypto_returns)+ portfolio_mean = sum(portfolio_returns) / len(portfolio_returns)++ combined_expected_return = (crypto_weight * crypto_mean ++ portfolio_weight * portfolio_mean)+ integration_analysis['expected_return_with_crypto'] = float(combined_expected_return)++ # Expected volatility+ crypto_vol = self.calculate_volatility(crypto_returns, annualized=False)+ portfolio_vol = self._calculate_volatility(portfolio_returns)++ # Portfolio variance with crypto+ combined_variance = (+ (crypto_weight ** 2) * (crypto_vol ** 2) ++ (portfolio_weight ** 2) * (portfolio_vol ** 2) ++ 2 * crypto_weight * portfolio_weight * portfolio_correlation * crypto_vol * portfolio_vol+ )++ combined_volatility = combined_variance.sqrt()+ integration_analysis['expected_volatility_with_crypto'] = float(combined_volatility)++ # Sharpe ratio comparison+ risk_free_rate = Config.RISK_FREE_RATE / Constants.MONTHS_IN_YEAR++ original_sharpe = (portfolio_mean - risk_free_rate) / portfolio_vol if portfolio_vol > 0 else Decimal('0')+ combined_sharpe = (+ combined_expected_return - risk_free_rate) / combined_volatility if combined_volatility > 0 else Decimal(+ '0')++ integration_analysis['original_sharpe_ratio'] = float(original_sharpe)+ integration_analysis['combined_sharpe_ratio'] = float(combined_sharpe)+ integration_analysis['sharpe_improvement'] = float(combined_sharpe - original_sharpe)++ # Diversification benefit+ diversification_ratio = combined_volatility / (crypto_weight * crypto_vol + portfolio_weight * portfolio_vol)+ integration_analysis['diversification_ratio'] = float(diversification_ratio)++ return integration_analysis++ def _calculate_volatility(self, returns: List[Decimal]) -> Decimal:+ """Calculate volatility of returns"""+ if len(returns) < 2:+ return Decimal('0')++ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ return variance.sqrt()++ def calculate_nav(self) -> Decimal:+ """Calculate digital asset NAV"""+ latest_price = self.get_latest_price()+ if latest_price:+ return latest_price++ # Fallback to market cap per token if available+ if self.market_cap and self.circulating_supply:+ return self.market_cap / self.circulating_supply++ return Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate comprehensive digital asset metrics"""+ metrics = {}++ # Fundamental metrics+ fundamental_metrics = self.fundamental_metrics()+ metrics.update(fundamental_metrics)++ # Volatility analysis+ vol_analysis = self.volatility_analysis()+ if 'error' not in vol_analysis:+ metrics.update(vol_analysis)++ # Risk assessment+ risk_metrics = self.risk_assessment()+ metrics.update(risk_metrics)++ # DeFi-specific analysis+ if self.asset_type == 'defi_token':+ defi_metrics = self.defi_protocol_analysis()+ if 'not_applicable' not in defi_metrics:+ metrics.update(defi_metrics)++ # Basic identifiers+ metrics['asset_type'] = self.asset_type+ metrics['blockchain'] = self.blockchain++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive digital asset valuation summary"""+ return {+ "asset_overview": {+ "asset_type": self.asset_type,+ "blockchain": self.blockchain,+ "market_cap": float(self.market_cap) if self.market_cap else None,+ "circulating_supply": float(self.circulating_supply) if self.circulating_supply else None,+ "trading_volume_24h": float(self.trading_volume_24h) if self.trading_volume_24h else None+ },+ "fundamental_analysis": self.fundamental_metrics(),+ "risk_analysis": self.risk_assessment(),+ "performance_metrics": self.calculate_key_metrics()+ }+++class DigitalAssetPortfolio:+ """+ Portfolio-level digital asset analysis+ CFA Standards: Portfolio construction and risk management+ """++ def __init__(self):+ self.digital_assets: List[DigitalAssetAnalyzer] = []++ def add_digital_asset(self, asset: DigitalAssetAnalyzer) -> None:+ """Add digital asset to portfolio"""+ self.digital_assets.append(asset)++ def portfolio_diversification(self) -> Dict[str, Any]:+ """Analyze portfolio diversification across digital asset types"""+ type_allocation = {}+ blockchain_allocation = {}+ total_nav = Decimal('0')++ for asset in self.digital_assets:+ asset_type = asset.asset_type+ blockchain = asset.blockchain+ nav = asset.calculate_nav()++ # Asset type allocation+ if asset_type not in type_allocation:+ type_allocation[asset_type] = {'count': 0, 'total_nav': Decimal('0')}+ type_allocation[asset_type]['count'] += 1+ type_allocation[asset_type]['total_nav'] += nav++ # Blockchain allocation+ if blockchain not in blockchain_allocation:+ blockchain_allocation[blockchain] = {'count': 0, 'total_nav': Decimal('0')}+ blockchain_allocation[blockchain]['count'] += 1+ blockchain_allocation[blockchain]['total_nav'] += nav++ total_nav += nav++ # Convert to percentages+ for allocation_dict in [type_allocation, blockchain_allocation]:+ for key in allocation_dict:+ allocation = allocation_dict[key]+ allocation['weight'] = float(allocation['total_nav'] / total_nav) if total_nav > 0 else 0+ allocation['total_nav'] = float(allocation['total_nav'])++ return {+ "asset_type_allocation": type_allocation,+ "blockchain_allocation": blockchain_allocation,+ "total_portfolio_nav": float(total_nav),+ "number_of_assets": len(self.digital_assets)+ }++ def portfolio_risk_metrics(self) -> Dict[str, Any]:+ """Calculate portfolio-level risk metrics"""+ all_returns = []+ weights = []+ total_nav = sum(asset.calculate_nav() for asset in self.digital_assets)++ # Collect returns and calculate weights+ for asset in self.digital_assets:+ asset_returns = asset.calculate_simple_returns()+ if asset_returns:+ all_returns.append(asset_returns)+ weight = asset.calculate_nav() / total_nav if total_nav > 0 else Decimal('0')+ weights.append(weight)++ if not all_returns:+ return {"error": "No return data available"}++ # Calculate portfolio returns (simplified equal weighting if NAV unavailable)+ if not weights:+ weights = [Decimal('1') / len(all_returns)] * len(all_returns)++ # Portfolio return series+ min_length = min(len(returns) for returns in all_returns)+ portfolio_returns = []++ for i in range(min_length):+ period_return = sum(weight * returns[i] for weight, returns in zip(weights, all_returns))+ portfolio_returns.append(period_return)++ if not portfolio_returns:+ return {"error": "Cannot calculate portfolio returns"}++ # Portfolio risk metrics+ portfolio_vol = self._calculate_portfolio_volatility(portfolio_returns)+ portfolio_var = self._calculate_var(portfolio_returns)++ return {+ "portfolio_volatility": float(portfolio_vol),+ "portfolio_var_95": float(portfolio_var),+ "number_of_periods": len(portfolio_returns),+ "correlation_weighted_risk": "high" # Digital assets typically highly correlated+ }++ def _calculate_portfolio_volatility(self, returns: List[Decimal]) -> Decimal:+ """Calculate portfolio volatility"""+ if len(returns) < 2:+ return Decimal('0')++ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ daily_vol = variance.sqrt()++ # Annualized volatility+ return daily_vol * Constants.DAYS_IN_YEAR.sqrt()++ def _calculate_var(self, returns: List[Decimal], confidence: Decimal = Decimal('0.05')) -> Decimal:+ """Calculate Value at Risk"""+ if not returns:+ return Decimal('0')++ sorted_returns = sorted(returns)+ var_index = int(len(sorted_returns) * confidence)++ if var_index >= len(sorted_returns):+ var_index = len(sorted_returns) - 1++ return abs(sorted_returns[var_index])+++# Export main components+__all__ = ['DigitalAssetAnalyzer', 'DigitalAssetPortfolio']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/hedge_funds.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/hedge_funds.pynew file mode 100644index 000000000..ead6d1072--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/hedge_funds.py@@ -0,0 +1,616 @@+"""+Hedge Fund Analytics Module+==========================++Comprehensive analysis framework for hedge fund investments across all major strategies including long/short equity, market neutral, event-driven, relative value, and opportunistic approaches. Provides performance measurement, risk assessment, and fee structure analysis.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical NAV and performance data for hedge funds+ - Strategy classification and exposure information+ - Gross and net exposure levels+ - Leverage and portfolio composition data+ - Management and performance fee structures+ - Redemption terms and liquidity constraints++OUTPUT:+ - Strategy-specific performance metrics and analytics+ - Risk-adjusted return calculations (Sharpe, Sortino, etc.)+ - Factor exposure analysis and attribution+ - Fee structure impact analysis+ - Liquidity risk assessment+ - Portfolio diversification analysis++PARAMETERS:+ - strategy: Hedge fund strategy type (LONG_SHORT_EQUITY, MARKET_NEUTRAL, etc.)+ - gross_exposure: Total gross exposure percentage+ - net_exposure: Net market exposure percentage+ - leverage: Leverage multiple - default: 1.0+ - management_fee: Annual management fee rate+ - performance_fee: Performance fee rate (typically 20%)+ - hurdle_rate: Performance hurdle rate - default: Config.HF_HURDLE_RATE_DEFAULT+ - high_water_mark: High water mark level - default: 100+ - redemption_frequency: Redemption frequency (daily, weekly, monthly, quarterly, annual)+ - lock_up_period: Lock-up period in months - default: 12+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config, HedgeFundStrategy+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class HedgeFundAnalyzer(AlternativeInvestmentBase):+ """+ Comprehensive hedge fund analysis across all strategies+ CFA Standards: Performance analysis, risk metrics, factor models+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.strategy = getattr(parameters, 'strategy', HedgeFundStrategy.LONG_SHORT_EQUITY)+ self.gross_exposure = getattr(parameters, 'gross_exposure', None)+ self.net_exposure = getattr(parameters, 'net_exposure', None)+ self.leverage = getattr(parameters, 'leverage', Decimal('1.0'))+ self.high_water_mark = getattr(parameters, 'high_water_mark', Decimal('100'))+ self.hurdle_rate = getattr(parameters, 'hurdle_rate', Config.HF_HURDLE_RATE_DEFAULT)+ self.redemption_frequency = getattr(parameters, 'redemption_frequency', 'quarterly')+ self.lock_up_period = getattr(parameters, 'lock_up_period', 12) # months++ def calculate_strategy_metrics(self) -> Dict[str, Any]:+ """+ Calculate strategy-specific metrics based on hedge fund type+ CFA Standards: Strategy classification and risk metrics+ """+ metrics = {}+ returns = self.calculate_simple_returns()++ if not returns:+ return {"error": "Insufficient return data"}++ # Base metrics for all strategies+ metrics.update(self._calculate_base_metrics(returns))++ # Strategy-specific analysis+ if self.strategy in [HedgeFundStrategy.LONG_SHORT_EQUITY,+ HedgeFundStrategy.EQUITY_MARKET_NEUTRAL,+ HedgeFundStrategy.DEDICATED_SHORT_BIAS]:+ metrics.update(self._analyze_equity_related_strategy(returns))++ elif self.strategy in [HedgeFundStrategy.MERGER_ARBITRAGE,+ HedgeFundStrategy.DISTRESSED_SECURITIES,+ HedgeFundStrategy.ACTIVIST]:+ metrics.update(self._analyze_event_driven_strategy(returns))++ elif self.strategy in [HedgeFundStrategy.FIXED_INCOME_ARBITRAGE,+ HedgeFundStrategy.CONVERTIBLE_ARBITRAGE,+ HedgeFundStrategy.VOLATILITY_ARBITRAGE]:+ metrics.update(self._analyze_relative_value_strategy(returns))++ elif self.strategy in [HedgeFundStrategy.GLOBAL_MACRO,+ HedgeFundStrategy.CTA_MANAGED_FUTURES]:+ metrics.update(self._analyze_opportunistic_strategy(returns))++ return metrics++ def _calculate_base_metrics(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Calculate base metrics common to all hedge fund strategies"""+ metrics = {}++ # Performance metrics+ total_return = sum(returns)+ avg_return = total_return / len(returns)+ volatility = self.calculate_volatility(returns, annualized=False)++ metrics['total_return'] = float(total_return)+ metrics['average_return'] = float(avg_return)+ metrics['volatility'] = float(volatility)++ # Risk-adjusted metrics+ sharpe = self.math.sharpe_ratio(returns)+ sortino = self.math.sortino_ratio(returns)++ metrics['sharpe_ratio'] = float(sharpe)+ metrics['sortino_ratio'] = float(sortino)++ # Drawdown analysis+ prices = [md.price for md in self.market_data]+ if prices:+ max_dd, peak_idx, trough_idx = self.math.maximum_drawdown(prices)+ metrics['maximum_drawdown'] = float(max_dd)++ # Exposure metrics+ if self.gross_exposure and self.net_exposure:+ metrics['gross_exposure'] = float(self.gross_exposure)+ metrics['net_exposure'] = float(self.net_exposure)+ metrics['leverage'] = float(self.leverage)++ return metrics++ def _analyze_equity_related_strategy(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze equity-related hedge fund strategies"""+ metrics = {}++ # Market exposure analysis+ if self.strategy == HedgeFundStrategy.LONG_SHORT_EQUITY:+ # Long/short specific metrics+ if self.gross_exposure and self.net_exposure:+ long_exposure = (self.gross_exposure + self.net_exposure) / Decimal('2')+ short_exposure = (self.gross_exposure - self.net_exposure) / Decimal('2')++ metrics['long_exposure'] = float(long_exposure)+ metrics['short_exposure'] = float(short_exposure)+ metrics['long_short_ratio'] = float(long_exposure / short_exposure) if short_exposure != 0 else None++ elif self.strategy == HedgeFundStrategy.EQUITY_MARKET_NEUTRAL:+ # Market neutrality metrics+ metrics['target_beta'] = 0.0+ metrics['expected_market_correlation'] = 'Low'++ elif self.strategy == HedgeFundStrategy.DEDICATED_SHORT_BIAS:+ # Short bias metrics+ metrics['short_bias'] = True+ metrics['expected_market_correlation'] = 'Negative'++ return metrics++ def _analyze_event_driven_strategy(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze event-driven hedge fund strategies"""+ metrics = {}++ # Event-driven characteristics+ if self.strategy == HedgeFundStrategy.MERGER_ARBITRAGE:+ # Merger arbitrage specific+ metrics['return_profile'] = 'steady_positive_with_tail_risk'+ metrics['market_correlation'] = 'low_in_normal_times'++ elif self.strategy == HedgeFundStrategy.DISTRESSED_SECURITIES:+ # Distressed specific+ metrics['return_profile'] = 'illiquid_with_high_returns'+ metrics['credit_sensitivity'] = 'high'++ elif self.strategy == HedgeFundStrategy.ACTIVIST:+ # Activist specific+ metrics['holding_period'] = 'long_term'+ metrics['concentration'] = 'high'++ # Calculate event-driven specific metrics+ win_rate = self._calculate_win_rate(returns)+ metrics['win_rate'] = win_rate++ return metrics++ def _analyze_relative_value_strategy(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze relative value hedge fund strategies"""+ metrics = {}++ if self.strategy == HedgeFundStrategy.FIXED_INCOME_ARBITRAGE:+ # Fixed income arbitrage+ metrics['duration_risk'] = 'managed'+ metrics['credit_risk'] = 'varies'+ metrics['leverage_typical'] = 'high'++ elif self.strategy == HedgeFundStrategy.CONVERTIBLE_ARBITRAGE:+ # Convertible arbitrage+ metrics['delta_hedging'] = True+ metrics['volatility_exposure'] = 'positive'++ elif self.strategy == HedgeFundStrategy.VOLATILITY_ARBITRAGE:+ # Volatility arbitrage+ metrics['volatility_exposure'] = 'primary_driver'+ metrics['gamma_trading'] = True++ # Relative value metrics+ consistency_ratio = self._calculate_consistency_ratio(returns)+ metrics['consistency_ratio'] = consistency_ratio++ return metrics++ def _analyze_opportunistic_strategy(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze opportunistic hedge fund strategies"""+ metrics = {}++ if self.strategy == HedgeFundStrategy.GLOBAL_MACRO:+ # Global macro+ metrics['investment_universe'] = 'global'+ metrics['asset_classes'] = 'multiple'+ metrics['leverage'] = 'variable'++ elif self.strategy == HedgeFundStrategy.CTA_MANAGED_FUTURES:+ # CTA/Managed futures+ metrics['approach'] = 'systematic_trend_following'+ metrics['diversification'] = 'high'+ metrics['crisis_alpha'] = 'potential'++ # Opportunistic metrics+ volatility = self.calculate_volatility(returns)+ metrics['return_volatility'] = float(volatility)++ return metrics++ def _calculate_win_rate(self, returns: List[Decimal]) -> float:+ """Calculate percentage of positive return periods"""+ if not returns:+ return 0.0++ positive_periods = sum(1 for r in returns if r > 0)+ return positive_periods / len(returns)++ def _calculate_consistency_ratio(self, returns: List[Decimal]) -> float:+ """Calculate return consistency (lower volatility relative to mean)"""+ if len(returns) < 2:+ return 0.0++ mean_return = sum(returns) / len(returns)+ volatility = self.calculate_volatility(returns, annualized=False)++ if volatility == 0:+ return float('inf')++ return float(abs(mean_return) / volatility)++ def fee_calculation(self, gross_returns: List[Decimal], nav_values: List[Decimal]) -> Dict[str, Any]:+ """+ Calculate hedge fund fees with high water mark+ CFA Standard: 2 and 20 fee structure with high water mark+ """+ if not all([gross_returns, nav_values, self.parameters.management_fee]):+ return {"error": "Insufficient data for fee calculation"}++ management_fee_rate = self.parameters.management_fee+ performance_fee_rate = self.parameters.performance_fee or Decimal('0.20')++ total_mgmt_fees = Decimal('0')+ total_perf_fees = Decimal('0')+ net_returns = []+ current_hwm = self.high_water_mark++ for i, (gross_ret, nav) in enumerate(zip(gross_returns, nav_values)):+ # Management fee (typically calculated on beginning NAV)+ beginning_nav = nav_values[i - 1] if i > 0 else nav+ mgmt_fee = beginning_nav * management_fee_rate / Constants.MONTHS_IN_YEAR+ total_mgmt_fees += mgmt_fee++ # Performance fee calculation+ perf_fee = Decimal('0')+ nav_after_mgmt_fee = nav - mgmt_fee++ # Check if above high water mark+ if nav_after_mgmt_fee > current_hwm:+ # Performance above hurdle rate+ hurdle_amount = beginning_nav * self.hurdle_rate / Constants.MONTHS_IN_YEAR++ if nav_after_mgmt_fee > (beginning_nav + hurdle_amount):+ excess_return = nav_after_mgmt_fee - max(current_hwm, beginning_nav + hurdle_amount)+ perf_fee = excess_return * performance_fee_rate++ # Update high water mark+ current_hwm = nav_after_mgmt_fee++ total_perf_fees += perf_fee++ # Net return after fees+ net_nav = nav_after_mgmt_fee - perf_fee+ net_return = (net_nav - beginning_nav) / beginning_nav if beginning_nav > 0 else Decimal('0')+ net_returns.append(net_return)++ return {+ "total_management_fees": float(total_mgmt_fees),+ "total_performance_fees": float(total_perf_fees),+ "total_fees": float(total_mgmt_fees + total_perf_fees),+ "net_returns": [float(r) for r in net_returns],+ "final_high_water_mark": float(current_hwm),+ "fee_drag": float((sum(gross_returns) - sum(net_returns)) / sum(gross_returns)) if sum(+ gross_returns) != 0 else 0+ }++ def factor_model_analysis(self, market_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]] = None) -> Dict[str, Any]:+ """+ Multi-factor model analysis for hedge fund returns+ CFA Standard: Factor model decomposition+ """+ fund_returns = self.calculate_simple_returns()++ if not fund_returns or not market_returns:+ return {"error": "Insufficient return data"}++ if len(fund_returns) != len(market_returns):+ return {"error": "Return series length mismatch"}++ analysis = {}++ # Single factor (market) model+ market_beta = self._calculate_beta(fund_returns, market_returns)+ market_alpha = self._calculate_alpha(fund_returns, market_returns, market_beta)++ analysis['market_beta'] = float(market_beta)+ analysis['market_alpha'] = float(market_alpha)++ # Multi-factor model if additional factors provided+ if factor_returns:+ factor_exposures = self._multi_factor_regression(fund_returns, market_returns, factor_returns)+ analysis['factor_exposures'] = factor_exposures++ # Strategy-specific factor analysis+ strategy_factors = self._get_strategy_factors()+ analysis['relevant_factors'] = strategy_factors++ return analysis++ def _calculate_beta(self, fund_returns: List[Decimal], market_returns: List[Decimal]) -> Decimal:+ """Calculate beta relative to market"""+ if len(fund_returns) != len(market_returns) or len(fund_returns) < 2:+ return Decimal('1')++ # Calculate covariance and market variance+ fund_mean = sum(fund_returns) / len(fund_returns)+ market_mean = sum(market_returns) / len(market_returns)++ covariance = sum((f - fund_mean) * (m - market_mean)+ for f, m in zip(fund_returns, market_returns)) / (len(fund_returns) - 1)++ market_variance = sum((m - market_mean) ** 2 for m in market_returns) / (len(market_returns) - 1)++ if market_variance == 0:+ return Decimal('1')++ return Decimal(str(covariance)) / Decimal(str(market_variance))++ def _calculate_alpha(self, fund_returns: List[Decimal], market_returns: List[Decimal], beta: Decimal) -> Decimal:+ """Calculate Jensen's alpha"""+ fund_mean = sum(fund_returns) / len(fund_returns)+ market_mean = sum(market_returns) / len(market_returns)+ risk_free = Config.RISK_FREE_RATE / Constants.MONTHS_IN_YEAR++ # Alpha = Fund Return - Risk Free - Beta * (Market Return - Risk Free)+ alpha = fund_mean - risk_free - beta * (market_mean - risk_free)+ return alpha++ def _multi_factor_regression(self, fund_returns: List[Decimal],+ market_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]]) -> Dict[str, float]:+ """Perform multi-factor regression analysis"""+ try:+ # Prepare data for regression+ y = np.array([float(r) for r in fund_returns])++ # Create factor matrix+ factors = [market_returns]+ factor_names = ['market']++ for factor_name, returns in factor_returns.items():+ if len(returns) == len(fund_returns):+ factors.append(returns)+ factor_names.append(factor_name)++ X = np.array([[float(factors[j][i]) for j in range(len(factors))]+ for i in range(len(fund_returns))])++ # Add intercept+ X = np.column_stack([np.ones(len(y)), X])++ # Perform regression+ coefficients = np.linalg.lstsq(X, y, rcond=None)[0]++ # Format results+ exposures = {'alpha': float(coefficients[0])}+ for i, factor_name in enumerate(factor_names):+ exposures[f'{factor_name}_beta'] = float(coefficients[i + 1])++ # Calculate R-squared+ y_pred = X @ coefficients+ ss_res = np.sum((y - y_pred) ** 2)+ ss_tot = np.sum((y - np.mean(y)) ** 2)+ r_squared = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0+ exposures['r_squared'] = float(r_squared)++ return exposures++ except Exception as e:+ logger.error(f"Error in multi-factor regression: {str(e)}")+ return {}++ def _get_strategy_factors(self) -> List[str]:+ """Get relevant factors for each strategy type"""+ strategy_factors = {+ HedgeFundStrategy.LONG_SHORT_EQUITY: ['market', 'size', 'value', 'momentum'],+ HedgeFundStrategy.EQUITY_MARKET_NEUTRAL: ['size', 'value', 'momentum', 'quality'],+ HedgeFundStrategy.MERGER_ARBITRAGE: ['volatility', 'credit_spreads'],+ HedgeFundStrategy.DISTRESSED_SECURITIES: ['credit_spreads', 'high_yield'],+ HedgeFundStrategy.FIXED_INCOME_ARBITRAGE: ['term_structure', 'credit_spreads'],+ HedgeFundStrategy.CONVERTIBLE_ARBITRAGE: ['volatility', 'credit_spreads', 'equity'],+ HedgeFundStrategy.GLOBAL_MACRO: ['currencies', 'commodities', 'bonds', 'equity'],+ HedgeFundStrategy.CTA_MANAGED_FUTURES: ['momentum', 'commodities', 'currencies']+ }++ return strategy_factors.get(self.strategy, ['market'])++ def liquidity_analysis(self) -> Dict[str, Any]:+ """+ Analyze hedge fund liquidity characteristics+ CFA Standard: Liquidity risk assessment+ """+ analysis = {+ "redemption_frequency": self.redemption_frequency,+ "lock_up_period_months": self.lock_up_period,+ "strategy": self.strategy.value+ }++ # Strategy-specific liquidity characteristics+ liquidity_profiles = {+ HedgeFundStrategy.EQUITY_MARKET_NEUTRAL: "high",+ HedgeFundStrategy.LONG_SHORT_EQUITY: "medium_high",+ HedgeFundStrategy.MERGER_ARBITRAGE: "medium",+ HedgeFundStrategy.CONVERTIBLE_ARBITRAGE: "medium",+ HedgeFundStrategy.DISTRESSED_SECURITIES: "low",+ HedgeFundStrategy.ACTIVIST: "low",+ HedgeFundStrategy.GLOBAL_MACRO: "high",+ HedgeFundStrategy.CTA_MANAGED_FUTURES: "high"+ }++ analysis["expected_liquidity"] = liquidity_profiles.get(self.strategy, "medium")++ # Liquidity risk score (1-5, 5 being highest risk)+ risk_scores = {+ "daily": 1,+ "weekly": 2,+ "monthly": 3,+ "quarterly": 4,+ "annual": 5+ }++ analysis["liquidity_risk_score"] = risk_scores.get(self.redemption_frequency, 3)++ return analysis++ def calculate_nav(self) -> Decimal:+ """Calculate hedge fund NAV"""+ latest_price = self.get_latest_price()+ return latest_price or Decimal('100') # Default to 100 if no price data++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate comprehensive hedge fund metrics"""+ metrics = {}++ # Strategy-specific metrics+ strategy_metrics = self.calculate_strategy_metrics()+ metrics.update(strategy_metrics)++ # Liquidity analysis+ liquidity_metrics = self.liquidity_analysis()+ metrics.update(liquidity_metrics)++ # Add strategy classification+ metrics['strategy'] = self.strategy.value+ metrics['leverage'] = float(self.leverage)++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive hedge fund analysis summary"""+ return {+ "fund_overview": {+ "strategy": self.strategy.value,+ "management_fee": float(self.parameters.management_fee) if self.parameters.management_fee else None,+ "performance_fee": float(self.parameters.performance_fee) if self.parameters.performance_fee else None,+ "hurdle_rate": float(self.hurdle_rate),+ "high_water_mark": float(self.high_water_mark),+ "leverage": float(self.leverage)+ },+ "performance_analysis": self.calculate_key_metrics(),+ "liquidity_profile": self.liquidity_analysis()+ }+++class HedgeFundPortfolio:+ """+ Portfolio-level hedge fund analysis+ CFA Standards: Multi-manager allocation and diversification+ """++ def __init__(self):+ self.hedge_funds: List[HedgeFundAnalyzer] = []++ def add_hedge_fund(self, hedge_fund: HedgeFundAnalyzer) -> None:+ """Add hedge fund to portfolio"""+ self.hedge_funds.append(hedge_fund)++ def strategy_diversification(self) -> Dict[str, Any]:+ """Analyze strategy diversification across portfolio"""+ strategy_allocation = {}+ total_nav = Decimal('0')++ for hf in self.hedge_funds:+ strategy = hf.strategy.value+ nav = hf.calculate_nav()++ if strategy not in strategy_allocation:+ strategy_allocation[strategy] = {+ 'count': 0,+ 'total_nav': Decimal('0')+ }++ strategy_allocation[strategy]['count'] += 1+ strategy_allocation[strategy]['total_nav'] += nav+ total_nav += nav++ # Convert to percentages+ for strategy in strategy_allocation:+ allocation = strategy_allocation[strategy]+ allocation['weight'] = float(allocation['total_nav'] / total_nav) if total_nav > 0 else 0+ allocation['total_nav'] = float(allocation['total_nav'])++ return {+ "strategy_allocation": strategy_allocation,+ "total_portfolio_nav": float(total_nav),+ "number_of_strategies": len(strategy_allocation),+ "number_of_funds": len(self.hedge_funds)+ }++ def portfolio_correlation_analysis(self) -> Dict[str, Any]:+ """Analyze correlations between hedge fund strategies"""+ if len(self.hedge_funds) < 2:+ return {"error": "Need at least 2 hedge funds for correlation analysis"}++ # Get returns for each fund+ fund_returns = {}+ for i, hf in enumerate(self.hedge_funds):+ returns = hf.calculate_simple_returns()+ if returns:+ fund_returns[f"fund_{i}_{hf.strategy.value}"] = returns++ if len(fund_returns) < 2:+ return {"error": "Insufficient return data"}++ # Calculate correlation matrix (simplified)+ correlations = {}+ fund_names = list(fund_returns.keys())++ for i, fund1 in enumerate(fund_names):+ for j, fund2 in enumerate(fund_names[i + 1:], i + 1):+ returns1 = fund_returns[fund1]+ returns2 = fund_returns[fund2]++ if len(returns1) == len(returns2) and len(returns1) > 1:+ correlation = self._calculate_correlation(returns1, returns2)+ correlations[f"{fund1}_vs_{fund2}"] = float(correlation)++ return {+ "pairwise_correlations": correlations,+ "funds_analyzed": fund_names+ }++ def _calculate_correlation(self, returns1: List[Decimal], returns2: List[Decimal]) -> Decimal:+ """Calculate correlation between two return series"""+ if len(returns1) != len(returns2) or len(returns1) < 2:+ return Decimal('0')++ mean1 = sum(returns1) / len(returns1)+ mean2 = sum(returns2) / len(returns2)++ numerator = sum((r1 - mean1) * (r2 - mean2) for r1, r2 in zip(returns1, returns2))++ sum_sq1 = sum((r1 - mean1) ** 2 for r1 in returns1)+ sum_sq2 = sum((r2 - mean2) ** 2 for r2 in returns2)++ denominator = (sum_sq1 * sum_sq2).sqrt()++ if denominator == 0:+ return Decimal('0')++ return numerator / denominator+++# Export main components+__all__ = ['HedgeFundAnalyzer', 'HedgeFundPortfolio']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/natural_resources.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/natural_resources.pynew file mode 100644index 000000000..1a8c6cc33--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/natural_resources.py@@ -0,0 +1,622 @@+"""+Natural Resources Analytics Module+==================================++Comprehensive analysis framework for natural resource investments including commodities, timberland, farmland, raw land, and energy projects. Provides specialized valuation methodologies for biological assets, commodity derivatives, and resource extraction investments.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Commodity spot and futures price data+ - Storage costs and convenience yields for commodities+ - Land acreage and acquisition costs+ - Timber volume and growth rates+ - Energy production data and reserves+ - Operating costs and revenue projections++OUTPUT:+ - Commodity futures basis and roll yield analysis+ - Natural resource valuation using specialized models+ - Total return decomposition for commodities+ - Land investment valuation (timberland, farmland, raw land)+ - Energy project valuation (oil & gas, renewable)++PARAMETERS:+ - commodity_sector: Sector classification (ENERGY, METALS, AGRICULTURE, LIVESTOCK)+ - spot_price: Current spot price of commodity+ - futures_prices: Dictionary of futures contract prices by expiry+ - storage_cost: Annual storage cost percentage - default: Config.COMMODITY_STORAGE_COST_TYPICAL+ - convenience_yield: Convenience yield rate - default: 0+ - contract_size: Contract size multiplier - default: 1+ - land_type: Type of land investment (timberland, farmland, raw_land)+ - acres: Total acreage of land investment+ - energy_type: Energy investment type (oil_gas, renewable)+ - proved_reserves: Reserves or capacity (barrels or MW)+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config, CommoditySector+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class CommodityAnalyzer(AlternativeInvestmentBase):+ """+ Commodity investment analysis and derivatives+ CFA Standards: Contango/backwardation, roll yield, futures pricing+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.commodity_sector = getattr(parameters, 'commodity_sector', CommoditySector.ENERGY)+ self.spot_price = getattr(parameters, 'spot_price', None)+ self.futures_prices = getattr(parameters, 'futures_prices', {}) # {expiry: price}+ self.storage_cost = getattr(parameters, 'storage_cost', Constants.COMMODITY_STORAGE_COST_TYPICAL)+ self.convenience_yield = getattr(parameters, 'convenience_yield', Decimal('0'))+ self.contract_size = getattr(parameters, 'contract_size', Decimal('1'))++ def calculate_futures_basis(self, futures_price: Decimal, expiry_months: int) -> Dict[str, Decimal]:+ """+ Calculate futures basis and determine market structure+ CFA Standard: Basis = Futures Price - Spot Price+ """+ if not self.spot_price:+ return {"error": "Spot price required"}++ basis = futures_price - self.spot_price+ basis_percentage = basis / self.spot_price++ # Determine market structure+ if basis > 0:+ market_structure = "contango"+ elif basis < 0:+ market_structure = "backwardation"+ else:+ market_structure = "neutral"++ # Annualized basis+ years_to_expiry = Decimal(str(expiry_months)) / Constants.MONTHS_IN_YEAR+ annualized_basis = basis_percentage / years_to_expiry if years_to_expiry > 0 else Decimal('0')++ return {+ "basis": basis,+ "basis_percentage": basis_percentage,+ "annualized_basis": annualized_basis,+ "market_structure": market_structure,+ "years_to_expiry": years_to_expiry+ }++ def theoretical_futures_price(self, time_to_expiry_years: Decimal,+ risk_free_rate: Decimal = None) -> Decimal:+ """+ Calculate theoretical futures price+ CFA Standard: F = S * e^((r + storage - convenience) * T)+ """+ if not self.spot_price:+ return Decimal('0')++ if risk_free_rate is None:+ risk_free_rate = Config.RISK_FREE_RATE++ # Net cost of carry+ cost_of_carry = risk_free_rate + self.storage_cost - self.convenience_yield++ # Theoretical futures price+ theoretical_price = self.spot_price * (Decimal('1') + cost_of_carry * time_to_expiry_years)++ return theoretical_price++ def roll_yield_analysis(self, front_month_price: Decimal,+ next_month_price: Decimal, days_to_roll: int) -> Dict[str, Decimal]:+ """+ Calculate roll yield for commodity futures+ CFA Standard: Roll yield from rolling futures positions+ """+ if days_to_roll <= 0:+ return {"error": "Invalid roll period"}++ # Roll yield calculation+ price_difference = next_month_price - front_month_price+ roll_yield = price_difference / front_month_price++ # Annualized roll yield+ days_in_year = float(Constants.DAYS_IN_YEAR)+ annualized_roll_yield = roll_yield * (Decimal(str(days_in_year)) / Decimal(str(days_to_roll)))++ return {+ "roll_yield": roll_yield,+ "annualized_roll_yield": annualized_roll_yield,+ "price_difference": price_difference,+ "days_to_roll": days_to_roll+ }++ def commodity_total_return(self, spot_returns: List[Decimal],+ roll_yields: List[Decimal],+ collateral_returns: List[Decimal]) -> Dict[str, Decimal]:+ """+ Calculate total return components for commodity investment+ CFA Standard: Total Return = Spot Return + Roll Yield + Collateral Return+ """+ if not all([spot_returns, roll_yields, collateral_returns]):+ return {"error": "All return components required"}++ if not (len(spot_returns) == len(roll_yields) == len(collateral_returns)):+ return {"error": "Return series must have equal length"}++ total_returns = []+ spot_component = Decimal('0')+ roll_component = Decimal('0')+ collateral_component = Decimal('0')++ for spot, roll, collateral in zip(spot_returns, roll_yields, collateral_returns):+ total_return = spot + roll + collateral+ total_returns.append(total_return)++ spot_component += spot+ roll_component += roll+ collateral_component += collateral++ periods = len(spot_returns)++ return {+ "total_return": sum(total_returns),+ "average_total_return": sum(total_returns) / periods,+ "spot_contribution": spot_component / periods,+ "roll_contribution": roll_component / periods,+ "collateral_contribution": collateral_component / periods,+ "periods": periods+ }++ def volatility_analysis(self, price_history: List[Decimal]) -> Dict[str, Decimal]:+ """Analyze commodity price volatility"""+ if len(price_history) < 2:+ return {"error": "Insufficient price history"}++ # Calculate returns+ returns = []+ for i in range(1, len(price_history)):+ ret = (price_history[i] - price_history[i - 1]) / price_history[i - 1]+ returns.append(ret)++ # Calculate volatility metrics+ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ volatility = variance.sqrt()++ # Annualized volatility (assuming daily data)+ annualized_vol = volatility * Constants.BUSINESS_DAYS_IN_YEAR.sqrt()++ return {+ "daily_volatility": volatility,+ "annualized_volatility": annualized_vol,+ "mean_daily_return": mean_return,+ "number_of_observations": len(returns)+ }++ def calculate_nav(self) -> Decimal:+ """Calculate commodity position NAV"""+ if self.spot_price:+ return self.spot_price * self.contract_size++ latest_price = self.get_latest_price()+ if latest_price:+ return latest_price * self.contract_size++ return Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key commodity metrics"""+ metrics = {}++ # Current pricing+ if self.spot_price:+ metrics['spot_price'] = float(self.spot_price)++ # Futures curve analysis+ if self.futures_prices:+ sorted_futures = sorted(self.futures_prices.items())+ metrics['futures_curve'] = {str(exp): float(price) for exp, price in sorted_futures}++ # Front month analysis+ if len(sorted_futures) >= 2:+ front_exp, front_price = sorted_futures[0]+ next_exp, next_price = sorted_futures[1]++ basis_analysis = self.calculate_futures_basis(front_price, 1) # 1 month+ metrics.update(basis_analysis)++ roll_analysis = self.roll_yield_analysis(front_price, next_price, 30) # 30 days+ if 'error' not in roll_analysis:+ metrics.update(roll_analysis)++ # Volatility analysis+ prices = [md.price for md in self.market_data]+ if prices:+ vol_analysis = self.volatility_analysis(prices)+ if 'error' not in vol_analysis:+ metrics.update(vol_analysis)++ metrics['commodity_sector'] = self.commodity_sector.value+ metrics['storage_cost'] = float(self.storage_cost)+ metrics['convenience_yield'] = float(self.convenience_yield)++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive commodity valuation summary"""+ return {+ "commodity_overview": {+ "sector": self.commodity_sector.value,+ "spot_price": float(self.spot_price) if self.spot_price else None,+ "contract_size": float(self.contract_size),+ "storage_cost": float(self.storage_cost),+ "convenience_yield": float(self.convenience_yield)+ },+ "market_analysis": self.calculate_key_metrics(),+ "futures_curve": self.futures_prices+ }+++class LandInvestmentAnalyzer(AlternativeInvestmentBase):+ """+ Land investment analysis - Timberland, Farmland, Raw Land+ CFA Standards: Natural resource valuation methods+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.land_type = getattr(parameters, 'land_type', 'timberland') # timberland, farmland, raw_land+ self.acres = getattr(parameters, 'acres', None)+ self.acquisition_price_per_acre = getattr(parameters, 'acquisition_price_per_acre', None)+ self.annual_revenue_per_acre = getattr(parameters, 'annual_revenue_per_acre', None)+ self.operating_expenses_per_acre = getattr(parameters, 'operating_expenses_per_acre', None)+ self.appreciation_rate = getattr(parameters, 'appreciation_rate', Decimal('0.03')) # 3% annual++ # Timberland specific+ self.timber_volume = getattr(parameters, 'timber_volume', None) # board feet or cubic meters+ self.growth_rate = getattr(parameters, 'growth_rate', Decimal('0.04')) # 4% annual volume growth+ self.harvest_cycle = getattr(parameters, 'harvest_cycle', 25) # years++ # Farmland specific+ self.crop_yield = getattr(parameters, 'crop_yield', None) # bushels per acre+ self.commodity_price = getattr(parameters, 'commodity_price', None) # price per bushel++ def timberland_valuation(self) -> Dict[str, Decimal]:+ """+ Timberland valuation using biological asset model+ CFA Standard: DCF with biological growth consideration+ """+ if self.land_type != 'timberland' or not all([self.timber_volume, self.acres]):+ return {"error": "Timberland parameters required"}++ discount_rate = Config.RISK_FREE_RATE + Decimal('0.04') # 4% risk premium++ # Land value (separate from timber)+ land_value = Decimal('0')+ if self.acquisition_price_per_acre:+ land_value = self.acquisition_price_per_acre * self.acres++ # Timber value with biological growth+ current_timber_value = self.timber_volume * self.acres++ # Project timber growth and harvest cycles+ total_timber_value = Decimal('0')+ years_to_project = 50 # Long-term projection++ for cycle in range(1, years_to_project // self.harvest_cycle + 1):+ harvest_year = cycle * self.harvest_cycle++ # Timber volume at harvest (with growth)+ harvest_volume = current_timber_value * ((Decimal('1') + self.growth_rate) ** harvest_year)++ # Assumed timber price per unit (simplified)+ timber_price_per_unit = Decimal('100') # per unit volume+ harvest_revenue = harvest_volume * timber_price_per_unit++ # Present value of harvest+ pv_harvest = harvest_revenue / ((Decimal('1') + discount_rate) ** harvest_year)+ total_timber_value += pv_harvest++ # Annual income from other sources (hunting leases, etc.)+ annual_income = (self.annual_revenue_per_acre or Decimal('0')) * self.acres+ annual_expenses = (self.operating_expenses_per_acre or Decimal('0')) * self.acres+ net_annual_income = annual_income - annual_expenses++ # PV of annual income stream+ if net_annual_income > 0:+ pv_annual_income = net_annual_income / discount_rate # Perpetuity+ else:+ pv_annual_income = Decimal('0')++ total_value = land_value + total_timber_value + pv_annual_income++ return {+ "total_timberland_value": total_value,+ "land_value": land_value,+ "timber_value": total_timber_value,+ "annual_income_value": pv_annual_income,+ "value_per_acre": total_value / self.acres if self.acres > 0 else Decimal('0')+ }++ def farmland_valuation(self) -> Dict[str, Decimal]:+ """+ Farmland valuation based on productive capacity+ CFA Standard: Income approach for agricultural land+ """+ if self.land_type != 'farmland' or not self.acres:+ return {"error": "Farmland parameters required"}++ # Income approach+ annual_gross_income = Decimal('0')+ if self.crop_yield and self.commodity_price:+ annual_gross_income = self.crop_yield * self.commodity_price * self.acres+ elif self.annual_revenue_per_acre:+ annual_gross_income = self.annual_revenue_per_acre * self.acres++ annual_expenses = (self.operating_expenses_per_acre or Decimal('0')) * self.acres+ net_operating_income = annual_gross_income - annual_expenses++ # Capitalization rate for farmland (typically lower than commercial real estate)+ cap_rate = Decimal('0.05') # 5% cap rate++ income_value = net_operating_income / cap_rate if cap_rate > 0 else Decimal('0')++ # Market approach (if acquisition price available)+ market_value = Decimal('0')+ if self.acquisition_price_per_acre:+ # Appreciate at assumed rate+ years_held = 1 # Simplified - would need actual holding period+ appreciated_price = self.acquisition_price_per_acre * (+ (Decimal('1') + self.appreciation_rate) ** years_held)+ market_value = appreciated_price * self.acres++ # Use higher of income or market value+ farmland_value = max(income_value, market_value)++ return {+ "farmland_value": farmland_value,+ "income_value": income_value,+ "market_value": market_value,+ "annual_noi": net_operating_income,+ "value_per_acre": farmland_value / self.acres if self.acres > 0 else Decimal('0'),+ "cap_rate": cap_rate+ }++ def raw_land_valuation(self) -> Dict[str, Decimal]:+ """+ Raw land valuation for development potential+ """+ if self.land_type != 'raw_land' or not self.acres:+ return {"error": "Raw land parameters required"}++ # Simple appreciation model+ current_value_per_acre = self.acquisition_price_per_acre or Decimal('1000') # Default $1000/acre++ # Project future value based on appreciation+ projection_years = 10+ future_value_per_acre = current_value_per_acre * ((Decimal('1') + self.appreciation_rate) ** projection_years)++ # Discount back to present (accounting for lack of income)+ discount_rate = Config.RISK_FREE_RATE + Decimal('0.06') # Higher risk premium for raw land+ present_value_per_acre = future_value_per_acre / ((Decimal('1') + discount_rate) ** projection_years)++ total_value = present_value_per_acre * self.acres++ return {+ "raw_land_value": total_value,+ "current_value_per_acre": current_value_per_acre,+ "projected_value_per_acre": future_value_per_acre,+ "present_value_per_acre": present_value_per_acre,+ "total_acres": self.acres+ }++ def calculate_nav(self) -> Decimal:+ """Calculate land investment NAV"""+ if self.land_type == 'timberland':+ valuation = self.timberland_valuation()+ return valuation.get('total_timberland_value', Decimal('0'))+ elif self.land_type == 'farmland':+ valuation = self.farmland_valuation()+ return valuation.get('farmland_value', Decimal('0'))+ elif self.land_type == 'raw_land':+ valuation = self.raw_land_valuation()+ return valuation.get('raw_land_value', Decimal('0'))++ return Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key land investment metrics"""+ metrics = {+ "land_type": self.land_type,+ "total_acres": float(self.acres) if self.acres else None,+ "appreciation_rate": float(self.appreciation_rate)+ }++ # Type-specific valuations+ if self.land_type == 'timberland':+ valuation = self.timberland_valuation()+ elif self.land_type == 'farmland':+ valuation = self.farmland_valuation()+ elif self.land_type == 'raw_land':+ valuation = self.raw_land_valuation()+ else:+ valuation = {}++ # Convert Decimal values to float+ for key, value in valuation.items():+ if isinstance(value, Decimal):+ metrics[key] = float(value)+ else:+ metrics[key] = value++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive land investment summary"""+ return {+ "land_overview": {+ "land_type": self.land_type,+ "total_acres": float(self.acres) if self.acres else None,+ "acquisition_price_per_acre": float(+ self.acquisition_price_per_acre) if self.acquisition_price_per_acre else None+ },+ "valuation_analysis": self.calculate_key_metrics()+ }+++class EnergyInvestmentAnalyzer(AlternativeInvestmentBase):+ """+ Energy investment analysis - Oil & Gas, Renewables+ CFA Standards: Energy project finance and valuation+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.energy_type = getattr(parameters, 'energy_type', 'oil_gas') # oil_gas, renewable+ self.proved_reserves = getattr(parameters, 'proved_reserves', None) # barrels or MW capacity+ self.daily_production = getattr(parameters, 'daily_production', None)+ self.decline_rate = getattr(parameters, 'decline_rate', Decimal('0.15')) # 15% annual decline+ self.operating_cost_per_unit = getattr(parameters, 'operating_cost_per_unit', None)+ self.commodity_price = getattr(parameters, 'commodity_price', None) # $/barrel or $/MWh++ # Renewable specific+ self.capacity_factor = getattr(parameters, 'capacity_factor', Decimal('0.35')) # 35%+ self.power_purchase_agreement = getattr(parameters, 'ppa_price', None) # $/MWh+ self.asset_life = getattr(parameters, 'asset_life', 25) # years++ def oil_gas_valuation(self) -> Dict[str, Decimal]:+ """+ Oil & Gas asset valuation using decline curve analysis+ CFA Standard: DCF with production decline+ """+ if self.energy_type != 'oil_gas':+ return {"error": "Oil & Gas parameters required"}++ if not all([self.daily_production, self.commodity_price]):+ return {"error": "Production and price data required"}++ discount_rate = Config.RISK_FREE_RATE + Decimal('0.08') # 8% risk premium+ projection_years = 20++ total_pv = Decimal('0')+ daily_prod = self.daily_production+ opex_per_unit = self.operating_cost_per_unit or Decimal('0')++ for year in range(1, projection_years + 1):+ # Annual production (accounting for decline)+ annual_production = daily_prod * Constants.DAYS_IN_YEAR++ # Revenue and costs+ annual_revenue = annual_production * self.commodity_price+ annual_opex = annual_production * opex_per_unit++ # Cash flow before taxes+ annual_cash_flow = annual_revenue - annual_opex++ # Present value+ pv = annual_cash_flow / ((Decimal('1') + discount_rate) ** year)+ total_pv += pv++ # Apply decline rate for next year+ daily_prod *= (Decimal('1') - self.decline_rate)++ return {+ "oil_gas_value": total_pv,+ "initial_daily_production": self.daily_production,+ "commodity_price": self.commodity_price,+ "decline_rate": self.decline_rate,+ "projection_years": projection_years+ }++ def renewable_energy_valuation(self) -> Dict[str, Decimal]:+ """+ Renewable energy project valuation+ CFA Standard: Project finance DCF+ """+ if self.energy_type != 'renewable':+ return {"error": "Renewable energy parameters required"}++ if not all([self.proved_reserves, self.capacity_factor]): # proved_reserves = capacity in MW+ return {"error": "Capacity and capacity factor required"}++ discount_rate = Config.RISK_FREE_RATE + Decimal('0.05') # 5% risk premium (lower than O&G)++ # Annual energy production+ capacity_mw = self.proved_reserves+ hours_per_year = Decimal('8760') # 24 * 365+ annual_mwh = capacity_mw * hours_per_year * self.capacity_factor++ # Revenue per year+ ppa_price = self.power_purchase_agreement or Decimal('50') # $50/MWh default+ annual_revenue = annual_mwh * ppa_price++ # Operating costs (simplified)+ annual_opex = capacity_mw * Decimal('25000') # $25,000 per MW per year++ # Annual cash flow+ annual_cash_flow = annual_revenue - annual_opex++ # Present value of cash flows+ total_pv = Decimal('0')+ for year in range(1, self.asset_life + 1):+ pv = annual_cash_flow / ((Decimal('1') + discount_rate) ** year)+ total_pv += pv++ return {+ "renewable_value": total_pv,+ "capacity_mw": capacity_mw,+ "annual_mwh": annual_mwh,+ "annual_revenue": annual_revenue,+ "annual_cash_flow": annual_cash_flow,+ "asset_life": self.asset_life+ }++ def calculate_nav(self) -> Decimal:+ """Calculate energy investment NAV"""+ if self.energy_type == 'oil_gas':+ valuation = self.oil_gas_valuation()+ return valuation.get('oil_gas_value', Decimal('0'))+ elif self.energy_type == 'renewable':+ valuation = self.renewable_energy_valuation()+ return valuation.get('renewable_value', Decimal('0'))++ return Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key energy investment metrics"""+ metrics = {+ "energy_type": self.energy_type+ }++ if self.energy_type == 'oil_gas':+ valuation = self.oil_gas_valuation()+ metrics.update({k: float(v) if isinstance(v, Decimal) else v for k, v in valuation.items()})+ elif self.energy_type == 'renewable':+ valuation = self.renewable_energy_valuation()+ metrics.update({k: float(v) if isinstance(v, Decimal) else v for k, v in valuation.items()})++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive energy investment summary"""+ return {+ "energy_overview": {+ "energy_type": self.energy_type,+ "proved_reserves": float(self.proved_reserves) if self.proved_reserves else None,+ "daily_production": float(self.daily_production) if self.daily_production else None+ },+ "valuation_analysis": self.calculate_key_metrics()+ }+++# Export main components+__all__ = ['CommodityAnalyzer', 'LandInvestmentAnalyzer', 'EnergyInvestmentAnalyzer']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/performance_metrics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/performance_metrics.pynew file mode 100644index 000000000..f29050a87--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/performance_metrics.py@@ -0,0 +1,670 @@+"""+Alternative Investment Performance Metrics Module+===============================================++Comprehensive performance measurement and analysis framework for alternative investments. Implements CFA Institute standard methodologies including time-weighted returns, money-weighted returns, risk-adjusted metrics, performance attribution, and fee impact analysis.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical market data and prices for investments+ - Cash flow data including contributions and distributions+ - Benchmark return series for comparison+ - Factor returns for multi-factor analysis+ - Fee structures and terms+ - Portfolio holdings and weights++OUTPUT:+ - Time-weighted and money-weighted return calculations+ - Risk-adjusted performance metrics (Sharpe, Sortino, Treynor, etc.)+ - Performance attribution analysis+ - Benchmark comparison and relative performance+ - Factor exposure analysis+ - Fee impact assessment and net-of-fee performance++PARAMETERS:+ - risk_free_rate: Risk-free rate for calculations - default: Config.RISK_FREE_RATE+ - benchmark_returns: Benchmark return series for comparison+ - factor_returns: Dictionary of factor return series+ - management_fee: Annual management fee rate for fee analysis+ - performance_fee: Performance fee rate+ - hurdle_rate: Hurdle rate for performance fees+ - high_water_mark: Whether high water mark applies+ - window_months: Rolling window size for performance analysis - default: 12+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetClass, Constants, Config+)+from base_analytics import FinancialMath++logger = logging.getLogger(__name__)++class PerformanceAnalyzer:+ """+ Comprehensive performance analysis for alternative investments+ Implements CFA Institute standard performance measurement methodologies+ """++ def __init__(self):+ self.math = FinancialMath()+ self.config = Config()++ def calculate_time_weighted_return(self, prices: List[MarketData],+ cash_flows: List[CashFlow] = None) -> Dict[str, Decimal]:+ """+ Calculate Time-Weighted Return (TWR)+ CFA Standard: Geometric mean of sub-period returns+ Eliminates the effect of cash flow timing++ Args:+ prices: List of MarketData objects+ cash_flows: Optional cash flows for adjustment++ Returns:+ Dictionary with TWR metrics+ """+ if len(prices) < 2:+ return {"error": "Insufficient price data"}++ # Sort prices by timestamp+ sorted_prices = sorted(prices, key=lambda x: x.timestamp)++ # Calculate sub-period returns+ returns = []+ for i in range(1, len(sorted_prices)):+ prev_price = sorted_prices[i-1].price+ curr_price = sorted_prices[i].price+ period_return = (curr_price - prev_price) / prev_price+ returns.append(period_return)++ # Calculate geometric mean (TWR)+ if not returns:+ return {"twr": Decimal('0')}++ cumulative_return = Decimal('1')+ for ret in returns:+ cumulative_return *= (Decimal('1') + ret)++ twr = cumulative_return - Decimal('1')++ # Annualize if we have enough data+ total_days = (datetime.strptime(sorted_prices[-1].timestamp[:10], '%Y-%m-%d') -+ datetime.strptime(sorted_prices[0].timestamp[:10], '%Y-%m-%d')).days++ if total_days > 0:+ years = Decimal(str(total_days)) / Constants.DAYS_IN_YEAR+ annualized_twr = (cumulative_return ** (Decimal('1') / years)) - Decimal('1')+ else:+ annualized_twr = twr++ return {+ "twr": twr,+ "annualized_twr": annualized_twr,+ "cumulative_return": cumulative_return - Decimal('1'),+ "number_of_periods": len(returns),+ "total_days": total_days+ }++ def calculate_money_weighted_return(self, cash_flows: List[CashFlow]) -> Dict[str, Decimal]:+ """+ Calculate Money-Weighted Return (MWR) using IRR+ CFA Standard: IRR of all cash flows including ending value+ Reflects the effect of cash flow timing++ Args:+ cash_flows: List of CashFlow objects++ Returns:+ Dictionary with MWR metrics+ """+ if not cash_flows:+ return {"error": "No cash flows provided"}++ irr = self.math.irr(cash_flows)++ if irr is None:+ return {"error": "Could not calculate IRR"}++ # Calculate other metrics+ moic = self.math.moic(cash_flows)+ dpi = self.math.dpi(cash_flows)++ return {+ "mwr_irr": irr,+ "moic": moic,+ "dpi": dpi,+ "total_cash_flows": len(cash_flows)+ }++ def calculate_risk_adjusted_returns(self, returns: List[Decimal],+ benchmark_returns: List[Decimal] = None) -> Dict[str, Decimal]:+ """+ Calculate comprehensive risk-adjusted return metrics+ CFA Standards: Sharpe, Treynor, Information, Sortino ratios++ Args:+ returns: Portfolio returns+ benchmark_returns: Benchmark returns for comparison++ Returns:+ Dictionary of risk-adjusted metrics+ """+ if len(returns) < 2:+ return {"error": "Insufficient return data"}++ metrics = {}++ # Basic statistics+ mean_return = sum(returns) / len(returns)+ volatility = self._calculate_volatility(returns)++ # Sharpe Ratio+ rf_rate = self.config.RISK_FREE_RATE / Constants.MONTHS_IN_YEAR # Monthly risk-free rate+ sharpe = self.math.sharpe_ratio(returns, rf_rate)+ metrics["sharpe_ratio"] = sharpe++ # Sortino Ratio+ sortino = self.math.sortino_ratio(returns)+ metrics["sortino_ratio"] = sortino++ # Calmar Ratio (need price series for max drawdown)+ if len(returns) > 1:+ # Approximate price series from returns+ prices = [Decimal('100')] # Start with base 100+ for ret in returns:+ prices.append(prices[-1] * (Decimal('1') + ret))++ max_dd, _, _ = self.math.maximum_drawdown(prices)+ annualized_return = mean_return * Constants.MONTHS_IN_YEAR # Assuming monthly returns+ calmar = self.math.calmar_ratio(annualized_return, max_dd)+ metrics["calmar_ratio"] = calmar+ metrics["maximum_drawdown"] = max_dd++ # Benchmark-relative metrics+ if benchmark_returns and len(benchmark_returns) == len(returns):+ # Tracking Error+ active_returns = [r - b for r, b in zip(returns, benchmark_returns)]+ tracking_error = self._calculate_volatility(active_returns)+ metrics["tracking_error"] = tracking_error++ # Information Ratio+ mean_active_return = sum(active_returns) / len(active_returns)+ if tracking_error > 0:+ information_ratio = mean_active_return / tracking_error+ metrics["information_ratio"] = information_ratio++ # Beta calculation+ if len(returns) > 1:+ beta = self._calculate_beta(returns, benchmark_returns)+ metrics["beta"] = beta++ # Treynor Ratio+ if beta != 0:+ treynor = (mean_return - rf_rate) / beta+ metrics["treynor_ratio"] = treynor++ # Value at Risk+ var_95 = self.math.var_historical(returns, Decimal('0.05'))+ var_99 = self.math.var_historical(returns, Decimal('0.01'))+ metrics["var_95"] = var_95+ metrics["var_99"] = var_99++ # Conditional VaR (Expected Shortfall)+ cvar_95 = self._calculate_cvar(returns, Decimal('0.05'))+ metrics["cvar_95"] = cvar_95++ return metrics++ def performance_attribution(self, portfolio_returns: List[Decimal],+ benchmark_returns: List[Decimal],+ sector_weights: Dict[str, Decimal] = None) -> Dict[str, Any]:+ """+ Perform return-based performance attribution analysis+ CFA Standard: Decompose excess returns into allocation and selection effects++ Args:+ portfolio_returns: Portfolio period returns+ benchmark_returns: Benchmark period returns+ sector_weights: Optional sector weight information++ Returns:+ Attribution analysis results+ """+ if len(portfolio_returns) != len(benchmark_returns):+ return {"error": "Portfolio and benchmark return lengths must match"}++ attribution = {}++ # Calculate basic attribution metrics+ active_returns = [p - b for p, b in zip(portfolio_returns, benchmark_returns)]++ portfolio_mean = sum(portfolio_returns) / len(portfolio_returns)+ benchmark_mean = sum(benchmark_returns) / len(benchmark_returns)+ active_mean = portfolio_mean - benchmark_mean++ attribution["total_active_return"] = active_mean+ attribution["portfolio_return"] = portfolio_mean+ attribution["benchmark_return"] = benchmark_mean++ # Hit rate (percentage of periods with positive active returns)+ positive_periods = sum(1 for ar in active_returns if ar > 0)+ hit_rate = Decimal(str(positive_periods)) / Decimal(str(len(active_returns)))+ attribution["hit_rate"] = hit_rate++ # Consistency metrics+ active_volatility = self._calculate_volatility(active_returns)+ attribution["active_volatility"] = active_volatility++ if active_volatility > 0:+ information_ratio = active_mean / active_volatility+ attribution["information_ratio"] = information_ratio++ return attribution++ def calculate_downside_metrics(self, returns: List[Decimal],+ target_return: Decimal = Decimal('0')) -> Dict[str, Decimal]:+ """+ Calculate comprehensive downside risk metrics+ CFA Standards: Downside deviation, downside beta, etc.++ Args:+ returns: Period returns+ target_return: Target or MAR (Minimum Acceptable Return)++ Returns:+ Dictionary of downside metrics+ """+ downside_metrics = {}++ # Downside deviation+ downside_returns = [min(r - target_return, Decimal('0')) for r in returns]+ downside_variance = sum(dr ** 2 for dr in downside_returns) / len(returns)+ downside_deviation = downside_variance.sqrt()+ downside_metrics["downside_deviation"] = downside_deviation++ # Sortino ratio+ mean_return = sum(returns) / len(returns)+ if downside_deviation > 0:+ sortino = (mean_return - target_return) / downside_deviation+ downside_metrics["sortino_ratio"] = sortino++ # Downside frequency+ negative_periods = sum(1 for r in returns if r < target_return)+ downside_frequency = Decimal(str(negative_periods)) / Decimal(str(len(returns)))+ downside_metrics["downside_frequency"] = downside_frequency++ # Average downside return+ negative_returns = [r for r in returns if r < target_return]+ if negative_returns:+ avg_downside = sum(negative_returns) / len(negative_returns)+ downside_metrics["average_downside_return"] = avg_downside++ return downside_metrics++ def rolling_performance(self, prices: List[MarketData], window_months: int = 12) -> List[Dict]:+ """+ Calculate rolling performance metrics++ Args:+ prices: List of MarketData objects+ window_months: Rolling window size in months++ Returns:+ List of rolling performance dictionaries+ """+ if len(prices) < window_months:+ return []++ rolling_results = []+ sorted_prices = sorted(prices, key=lambda x: x.timestamp)++ for i in range(window_months, len(sorted_prices)):+ window_prices = sorted_prices[i-window_months:i+1]++ # Calculate returns for the window+ window_returns = []+ for j in range(1, len(window_prices)):+ ret = (window_prices[j].price - window_prices[j-1].price) / window_prices[j-1].price+ window_returns.append(ret)++ if window_returns:+ period_return = (window_prices[-1].price - window_prices[0].price) / window_prices[0].price+ volatility = self._calculate_volatility(window_returns)+ sharpe = self.math.sharpe_ratio(window_returns)++ rolling_results.append({+ "end_date": window_prices[-1].timestamp,+ "period_return": float(period_return),+ "annualized_return": float(period_return * Constants.MONTHS_IN_YEAR / window_months),+ "volatility": float(volatility),+ "sharpe_ratio": float(sharpe)+ })++ return rolling_results++ def calculate_factor_exposures(self, portfolio_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]]) -> Dict[str, Decimal]:+ """+ Calculate factor exposures using multiple regression+ CFA Standard: Multi-factor model analysis++ Args:+ portfolio_returns: Portfolio returns+ factor_returns: Dictionary of factor name -> factor returns++ Returns:+ Dictionary of factor loadings (betas)+ """+ if not factor_returns or len(portfolio_returns) < 10:+ return {}++ # Ensure all factor return series have same length as portfolio+ valid_factors = {}+ for factor_name, returns in factor_returns.items():+ if len(returns) == len(portfolio_returns):+ valid_factors[factor_name] = returns++ if not valid_factors:+ return {}++ try:+ # Convert to numpy arrays for regression+ y = np.array([float(r) for r in portfolio_returns])+ X = np.array([[float(valid_factors[factor][i]) for factor in valid_factors.keys()]+ for i in range(len(portfolio_returns))])++ # Add intercept term+ X = np.column_stack([np.ones(len(y)), X])++ # Ordinary least squares regression+ beta = np.linalg.lstsq(X, y, rcond=None)[0]++ exposures = {"alpha": Decimal(str(beta[0]))}+ for i, factor_name in enumerate(valid_factors.keys()):+ exposures[f"{factor_name}_beta"] = Decimal(str(beta[i+1]))++ # Calculate R-squared+ y_pred = X @ beta+ ss_res = np.sum((y - y_pred) ** 2)+ ss_tot = np.sum((y - np.mean(y)) ** 2)+ r_squared = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0+ exposures["r_squared"] = Decimal(str(r_squared))++ return exposures++ except Exception as e:+ logger.error(f"Error calculating factor exposures: {str(e)}")+ return {}++ def benchmark_analysis(self, portfolio_returns: List[Decimal],+ benchmark_returns: List[Decimal]) -> Dict[str, Any]:+ """+ Comprehensive benchmark analysis+ CFA Standards: Up/down capture, batting average, etc.++ Args:+ portfolio_returns: Portfolio returns+ benchmark_returns: Benchmark returns++ Returns:+ Dictionary of benchmark analysis metrics+ """+ if len(portfolio_returns) != len(benchmark_returns):+ return {"error": "Return series length mismatch"}++ analysis = {}++ # Up/Down Capture Ratios+ up_periods = [(p, b) for p, b in zip(portfolio_returns, benchmark_returns) if b > 0]+ down_periods = [(p, b) for p, b in zip(portfolio_returns, benchmark_returns) if b < 0]++ if up_periods:+ up_portfolio = sum(p for p, b in up_periods) / len(up_periods)+ up_benchmark = sum(b for p, b in up_periods) / len(up_periods)+ up_capture = up_portfolio / up_benchmark if up_benchmark != 0 else Decimal('0')+ analysis["up_capture_ratio"] = up_capture++ if down_periods:+ down_portfolio = sum(p for p, b in down_periods) / len(down_periods)+ down_benchmark = sum(b for p, b in down_periods) / len(down_periods)+ down_capture = down_portfolio / down_benchmark if down_benchmark != 0 else Decimal('0')+ analysis["down_capture_ratio"] = down_capture++ # Batting Average (percentage of periods outperforming benchmark)+ outperformance_periods = sum(1 for p, b in zip(portfolio_returns, benchmark_returns) if p > b)+ batting_average = Decimal(str(outperformance_periods)) / Decimal(str(len(portfolio_returns)))+ analysis["batting_average"] = batting_average++ # Beta and correlation+ beta = self._calculate_beta(portfolio_returns, benchmark_returns)+ correlation = self._calculate_correlation(portfolio_returns, benchmark_returns)+ analysis["beta"] = beta+ analysis["correlation"] = correlation++ return analysis++ def performance_persistence(self, returns_by_period: List[List[Decimal]]) -> Dict[str, Any]:+ """+ Analyze performance persistence across periods++ Args:+ returns_by_period: List of return lists for different periods++ Returns:+ Persistence analysis metrics+ """+ if len(returns_by_period) < 2:+ return {"error": "Need at least 2 periods for persistence analysis"}++ persistence = {}++ # Calculate rankings for each period+ period_rankings = []+ for period_returns in returns_by_period:+ if not period_returns:+ continue+ sorted_returns = sorted(period_returns, reverse=True)+ rankings = []+ for ret in period_returns:+ rank = sorted_returns.index(ret) + 1+ rankings.append(rank)+ period_rankings.append(rankings)++ if len(period_rankings) < 2:+ return {"error": "Insufficient valid periods"}++ # Calculate rank correlation between consecutive periods+ correlations = []+ for i in range(len(period_rankings) - 1):+ corr = self._calculate_rank_correlation(period_rankings[i], period_rankings[i+1])+ correlations.append(corr)++ persistence["rank_correlations"] = correlations+ persistence["average_rank_correlation"] = sum(correlations) / len(correlations) if correlations else Decimal('0')++ return persistence++ def _calculate_volatility(self, returns: List[Decimal]) -> Decimal:+ """Calculate standard deviation of returns"""+ if len(returns) < 2:+ return Decimal('0')++ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ return variance.sqrt()++ def _calculate_beta(self, portfolio_returns: List[Decimal],+ benchmark_returns: List[Decimal]) -> Decimal:+ """Calculate beta (systematic risk measure)"""+ if len(portfolio_returns) != len(benchmark_returns) or len(portfolio_returns) < 2:+ return Decimal('1')++ # Calculate covariance and benchmark variance+ port_mean = sum(portfolio_returns) / len(portfolio_returns)+ bench_mean = sum(benchmark_returns) / len(benchmark_returns)++ covariance = sum((p - port_mean) * (b - bench_mean)+ for p, b in zip(portfolio_returns, benchmark_returns)) / (len(portfolio_returns) - 1)++ bench_variance = sum((b - bench_mean) ** 2 for b in benchmark_returns) / (len(benchmark_returns) - 1)++ if bench_variance == 0:+ return Decimal('1')++ return Decimal(str(covariance)) / Decimal(str(bench_variance))++ def _calculate_correlation(self, x: List[Decimal], y: List[Decimal]) -> Decimal:+ """Calculate correlation coefficient"""+ if len(x) != len(y) or len(x) < 2:+ return Decimal('0')++ x_mean = sum(x) / len(x)+ y_mean = sum(y) / len(y)++ numerator = sum((xi - x_mean) * (yi - y_mean) for xi, yi in zip(x, y))+ x_sq_sum = sum((xi - x_mean) ** 2 for xi in x)+ y_sq_sum = sum((yi - y_mean) ** 2 for yi in y)++ denominator = (x_sq_sum * y_sq_sum).sqrt()++ if denominator == 0:+ return Decimal('0')++ return numerator / denominator++ def _calculate_rank_correlation(self, ranks1: List[int], ranks2: List[int]) -> Decimal:+ """Calculate Spearman rank correlation"""+ if len(ranks1) != len(ranks2) or len(ranks1) < 2:+ return Decimal('0')++ n = len(ranks1)+ d_squared_sum = sum((r1 - r2) ** 2 for r1, r2 in zip(ranks1, ranks2))++ correlation = Decimal('1') - (Decimal('6') * Decimal(str(d_squared_sum))) / (Decimal(str(n)) * (Decimal(str(n))**2 - Decimal('1')))++ return correlation++ def _calculate_cvar(self, returns: List[Decimal], confidence_level: Decimal) -> Decimal:+ """Calculate Conditional Value at Risk (Expected Shortfall)"""+ if not returns:+ return Decimal('0')++ sorted_returns = sorted(returns)+ var_index = int(len(sorted_returns) * confidence_level)++ if var_index >= len(sorted_returns):+ var_index = len(sorted_returns) - 1++ # Average of returns at or below VaR level+ tail_returns = sorted_returns[:var_index + 1]+ if not tail_returns:+ return Decimal('0')++ cvar = sum(tail_returns) / len(tail_returns)+ return abs(cvar)++class FeeAnalyzer:+ """+ Analyze fee structures and their impact on performance+ CFA Standards: Fee transparency and impact analysis+ """++ def __init__(self):+ self.config = Config()++ def calculate_fee_impact(self, gross_returns: List[Decimal],+ management_fee: Decimal,+ performance_fee: Decimal = None,+ hurdle_rate: Decimal = None,+ high_water_mark: bool = True) -> Dict[str, Any]:+ """+ Calculate the impact of fees on investment returns++ Args:+ gross_returns: Gross returns before fees+ management_fee: Annual management fee rate+ performance_fee: Performance fee rate (if applicable)+ hurdle_rate: Hurdle rate for performance fees+ high_water_mark: Whether high water mark applies++ Returns:+ Fee impact analysis+ """+ if not gross_returns:+ return {"error": "No returns provided"}++ net_returns = []+ cumulative_nav = Decimal('100') # Start with 100 base value+ high_water_mark_value = cumulative_nav if high_water_mark else None++ periods_per_year = 12 # Assume monthly returns+ monthly_mgmt_fee = management_fee / periods_per_year++ total_mgmt_fees = Decimal('0')+ total_perf_fees = Decimal('0')++ for gross_return in gross_returns:+ # Apply gross return+ period_nav = cumulative_nav * (Decimal('1') + gross_return)++ # Calculate management fee+ mgmt_fee_amount = cumulative_nav * monthly_mgmt_fee+ total_mgmt_fees += mgmt_fee_amount++ # Calculate performance fee+ perf_fee_amount = Decimal('0')+ if performance_fee and performance_fee > 0:+ if hurdle_rate:+ monthly_hurdle = hurdle_rate / periods_per_year+ hurdle_return = cumulative_nav * monthly_hurdle+ else:+ hurdle_return = Decimal('0')++ excess_return = max(Decimal('0'), (period_nav - cumulative_nav) - hurdle_return)++ if high_water_mark and high_water_mark_value:+ if period_nav > high_water_mark_value:+ perf_fee_amount = excess_return * performance_fee+ high_water_mark_value = period_nav+ else:+ perf_fee_amount = excess_return * performance_fee++ total_perf_fees += perf_fee_amount++ # Calculate net return after fees+ net_nav = period_nav - mgmt_fee_amount - perf_fee_amount+ net_return = (net_nav - cumulative_nav) / cumulative_nav+ net_returns.append(net_return)++ cumulative_nav = net_nav++ # Calculate summary statistics+ gross_cumulative = Decimal('1')+ net_cumulative = Decimal('1')++ for gross_ret, net_ret in zip(gross_returns, net_returns):+ gross_cumulative *= (Decimal('1') + gross_ret)+ net_cumulative *= (Decimal('1') + net_ret)++ fee_drag = (gross_cumulative - net_cumulative) / gross_cumulative++ return {+ "gross_cumulative_return": gross_cumulative - Decimal('1'),+ "net_cumulative_return": net_cumulative - Decimal('1'),+ "total_fee_drag": fee_drag,+ "total_management_fees": total_mgmt_fees,+ "total_performance_fees": total_perf_fees,+ "total_fees": total_mgmt_fees + total_perf_fees,+ "net_returns": net_returns,+ "fee_ratio": (total_mgmt_fees + total_perf_fees) / (cumulative_nav * len(gross_returns))+ }++# Export main components+__all__ = ['PerformanceAnalyzer', 'FeeAnalyzer']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/private_capital.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/private_capital.pynew file mode 100644index 000000000..49e938be3--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/private_capital.py@@ -0,0 +1,549 @@+"""+Private Capital Analytics Module+================================++Comprehensive analysis framework for private capital investments including private equity funds, private debt instruments, and direct investments. Provides specialized valuation methodologies, performance metrics, and cash flow analysis for illiquid investment vehicles.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Capital calls and distribution cash flow data+ - Fund NAV values and reporting dates+ - Commitment amounts and vintage years+ - Private debt instrument details (principal, coupon, maturity)+ - Credit ratings and seniority information for debt investments+ - Fee structures and terms++OUTPUT:+ - IRR, MOIC, DPI, RVPI, TVPI performance metrics+ - Private equity fund performance analysis+ - Private debt yield and duration calculations+ - Credit risk assessment for debt instruments+ - Portfolio-level private capital analysis++PARAMETERS:+ - fund_life: Expected fund life in years - default: Constants.PE_TYPICAL_FUND_LIFE+ - vintage_year: Fund vintage year+ - commitment: Total commitment amount+ - principal_amount: Principal amount for debt investments+ - coupon_rate: Annual coupon rate for debt instruments+ - maturity_date: Maturity date for debt instruments+ - credit_rating: Credit rating for debt investments+ - seniority: Debt seniority level (senior, mezzanine, subordinated) - default: senior+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config, InvestmentMethod+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class PrivateEquityAnalyzer(AlternativeInvestmentBase):+ """+ Private Equity investment analysis and valuation+ CFA Standards: IRR, MOIC, DPI, RVPI calculations and due diligence+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.fund_life = getattr(parameters, 'fund_life', Constants.PE_TYPICAL_FUND_LIFE)+ self.vintage_year = getattr(parameters, 'vintage_year', None)+ self.commitment = getattr(parameters, 'commitment', None)+ self.called_capital = Decimal('0')+ self.distributed_capital = Decimal('0')+ self.current_nav = Decimal('0')++ def add_commitment(self, commitment_amount: Decimal, vintage_year: int) -> None:+ """Record fund commitment"""+ self.commitment = commitment_amount+ self.vintage_year = vintage_year++ def process_capital_call(self, amount: Decimal, call_date: str, description: str = None) -> None:+ """Process capital call from fund"""+ cash_flow = CashFlow(+ date=call_date,+ amount=-abs(amount), # Negative for outflow+ cf_type='capital_call',+ description=description or f"Capital call - {call_date}"+ )+ self.add_cash_flows([cash_flow])+ self.called_capital += abs(amount)++ def process_distribution(self, amount: Decimal, dist_date: str,+ distribution_type: str = 'distribution') -> None:+ """Process distribution from fund"""+ cash_flow = CashFlow(+ date=dist_date,+ amount=amount,+ cf_type=distribution_type,+ description=f"{distribution_type} - {dist_date}"+ )+ self.add_cash_flows([cash_flow])+ self.distributed_capital += amount++ def update_nav(self, nav_value: Decimal, nav_date: str) -> None:+ """Update current Net Asset Value"""+ self.current_nav = nav_value+ # Add as market data point+ market_data = MarketData(+ timestamp=nav_date,+ price=nav_value,+ volume=None+ )+ self.add_market_data([market_data])++ def calculate_nav(self) -> Decimal:+ """Calculate current NAV"""+ return self.current_nav++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """+ Calculate key PE metrics following CFA standards+ """+ if not self.cash_flows:+ return {"error": "No cash flows available"}++ metrics = {}++ # IRR Calculation+ # Add current NAV as final cash flow for IRR calculation+ cf_for_irr = self.cash_flows.copy()+ if self.current_nav > 0:+ latest_date = max(cf.date for cf in self.cash_flows) if self.cash_flows else datetime.now().strftime(+ '%Y-%m-%d')+ cf_for_irr.append(CashFlow(+ date=latest_date,+ amount=self.current_nav,+ cf_type='nav',+ description='Current NAV'+ ))++ irr = self.math.irr(cf_for_irr)+ metrics['irr'] = float(irr) if irr else None++ # MOIC (Multiple of Invested Capital)+ moic = self.math.moic(cf_for_irr)+ metrics['moic'] = float(moic) if moic else None++ # DPI (Distributions to Paid-In Capital)+ dpi = self.math.dpi(self.cash_flows)+ metrics['dpi'] = float(dpi)++ # RVPI (Residual Value to Paid-In Capital)+ rvpi = self.math.rvpi(self.cash_flows, self.current_nav)+ metrics['rvpi'] = float(rvpi)++ # TVPI (Total Value to Paid-In Capital) = DPI + RVPI+ tvpi = dpi + rvpi+ metrics['tvpi'] = float(tvpi)++ # Fund metrics+ if self.commitment:+ called_ratio = self.called_capital / self.commitment+ metrics['called_capital_ratio'] = float(called_ratio)+ metrics['uncalled_commitment'] = float(self.commitment - self.called_capital)++ metrics['called_capital'] = float(self.called_capital)+ metrics['distributed_capital'] = float(self.distributed_capital)+ metrics['current_nav'] = float(self.current_nav)++ # Vintage year analysis+ if self.vintage_year:+ current_year = datetime.now().year+ fund_age = current_year - self.vintage_year+ metrics['fund_age'] = fund_age+ metrics['vintage_year'] = self.vintage_year++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive PE valuation summary"""+ key_metrics = self.calculate_key_metrics()++ valuation = {+ "investment_overview": {+ "asset_class": self.parameters.asset_class.value,+ "fund_name": self.parameters.name,+ "vintage_year": self.vintage_year,+ "commitment": float(self.commitment) if self.commitment else None+ },+ "capital_account": {+ "total_commitment": float(self.commitment) if self.commitment else None,+ "called_capital": float(self.called_capital),+ "uncalled_commitment": float(self.commitment - self.called_capital) if self.commitment else None,+ "distributed_capital": float(self.distributed_capital),+ "current_nav": float(self.current_nav)+ },+ "performance_metrics": key_metrics,+ "cash_flow_summary": {+ "number_of_capital_calls": len([cf for cf in self.cash_flows if cf.cf_type == 'capital_call']),+ "number_of_distributions": len([cf for cf in self.cash_flows if cf.cf_type == 'distribution']),+ "total_cash_flows": len(self.cash_flows)+ }+ }++ return valuation++ def benchmark_comparison(self, benchmark_irr: Decimal, benchmark_moic: Decimal) -> Dict[str, Any]:+ """Compare performance against benchmark"""+ metrics = self.calculate_key_metrics()++ if not metrics.get('irr') or not metrics.get('moic'):+ return {"error": "Insufficient data for benchmark comparison"}++ fund_irr = Decimal(str(metrics['irr']))+ fund_moic = Decimal(str(metrics['moic']))++ comparison = {+ "fund_performance": {+ "irr": float(fund_irr),+ "moic": float(fund_moic)+ },+ "benchmark_performance": {+ "irr": float(benchmark_irr),+ "moic": float(benchmark_moic)+ },+ "relative_performance": {+ "irr_difference": float(fund_irr - benchmark_irr),+ "moic_difference": float(fund_moic - benchmark_moic),+ "irr_outperformance": fund_irr > benchmark_irr,+ "moic_outperformance": fund_moic > benchmark_moic+ }+ }++ return comparison+++class PrivateDebtAnalyzer(AlternativeInvestmentBase):+ """+ Private Debt investment analysis and risk assessment+ CFA Standards: Credit analysis, yield calculations, duration+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.principal_amount = getattr(parameters, 'principal_amount', None)+ self.coupon_rate = getattr(parameters, 'coupon_rate', None)+ self.maturity_date = getattr(parameters, 'maturity_date', None)+ self.credit_rating = getattr(parameters, 'credit_rating', None)+ self.seniority = getattr(parameters, 'seniority', 'senior') # senior, mezzanine, subordinated+ self.current_price = Decimal('100') # Par = 100++ def calculate_current_yield(self) -> Decimal:+ """Calculate current yield"""+ if not self.coupon_rate or self.current_price == 0:+ return Decimal('0')++ annual_coupon = self.principal_amount * self.coupon_rate if self.principal_amount else self.coupon_rate+ return annual_coupon / self.current_price++ def calculate_yield_to_maturity(self, current_price: Decimal = None) -> Optional[Decimal]:+ """+ Calculate Yield to Maturity using approximation method+ CFA Standard: YTM calculation for bonds+ """+ if not all([self.coupon_rate, self.maturity_date, self.principal_amount]):+ return None++ price = current_price or self.current_price++ # Simple approximation for YTM+ # YTM ≈ [Annual Coupon + (Face Value - Price) / Years to Maturity] / [(Face Value + Price) / 2]++ maturity = datetime.strptime(self.maturity_date, '%Y-%m-%d')+ years_to_maturity = (maturity - datetime.now()).days / 365.25++ if years_to_maturity <= 0:+ return self.coupon_rate++ face_value = Decimal('100') # Assuming par value of 100+ annual_coupon = self.coupon_rate * face_value++ numerator = annual_coupon + (face_value - price) / Decimal(str(years_to_maturity))+ denominator = (face_value + price) / Decimal('2')++ ytm = numerator / denominator+ return ytm++ def calculate_duration(self, ytm: Decimal = None) -> Dict[str, Decimal]:+ """+ Calculate Macaulay and Modified Duration+ CFA Standard: Duration as price sensitivity measure+ """+ if not all([self.coupon_rate, self.maturity_date]):+ return {}++ if ytm is None:+ ytm = self.calculate_yield_to_maturity()+ if ytm is None:+ return {}++ maturity = datetime.strptime(self.maturity_date, '%Y-%m-%d')+ years_to_maturity = (maturity - datetime.now()).days / 365.25++ if years_to_maturity <= 0:+ return {}++ # Simplified duration calculation for annual payments+ coupon_rate = self.coupon_rate+ periods = int(years_to_maturity)++ # Macaulay Duration+ pv_weighted_time = Decimal('0')+ total_pv = Decimal('0')++ for t in range(1, periods + 1):+ if t < periods:+ cash_flow = coupon_rate * Decimal('100') # Coupon payment+ else:+ cash_flow = (coupon_rate * Decimal('100')) + Decimal('100') # Coupon + Principal++ pv = cash_flow / ((Decimal('1') + ytm) ** t)+ pv_weighted_time += pv * Decimal(str(t))+ total_pv += pv++ macaulay_duration = pv_weighted_time / total_pv if total_pv > 0 else Decimal('0')++ # Modified Duration+ modified_duration = macaulay_duration / (Decimal('1') + ytm)++ return {+ "macaulay_duration": macaulay_duration,+ "modified_duration": modified_duration,+ "years_to_maturity": Decimal(str(years_to_maturity))+ }++ def credit_risk_assessment(self) -> Dict[str, Any]:+ """+ Assess credit risk characteristics+ CFA Standard: Credit analysis framework+ """+ assessment = {+ "credit_profile": {+ "credit_rating": self.credit_rating,+ "seniority": self.seniority,+ "principal_amount": float(self.principal_amount) if self.principal_amount else None,+ "coupon_rate": float(self.coupon_rate) if self.coupon_rate else None,+ "maturity_date": self.maturity_date+ }+ }++ # Credit spread analysis (simplified)+ if self.coupon_rate:+ risk_free_rate = Config.RISK_FREE_RATE+ credit_spread = self.coupon_rate - risk_free_rate+ assessment["credit_spread"] = float(credit_spread)+ assessment["credit_spread_bps"] = float(credit_spread * Constants.BASIS_POINTS)++ # Risk categorization based on seniority+ risk_factors = {+ "senior": {"recovery_rate": 0.80, "risk_weight": 1.0},+ "mezzanine": {"recovery_rate": 0.50, "risk_weight": 1.5},+ "subordinated": {"recovery_rate": 0.20, "risk_weight": 2.0}+ }++ if self.seniority in risk_factors:+ assessment["risk_characteristics"] = risk_factors[self.seniority]++ return assessment++ def calculate_nav(self) -> Decimal:+ """Calculate current NAV based on market price"""+ if self.principal_amount:+ return self.principal_amount * (self.current_price / Decimal('100'))+ return self.current_price++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key private debt metrics"""+ metrics = {}++ # Yield metrics+ current_yield = self.calculate_current_yield()+ ytm = self.calculate_yield_to_maturity()++ metrics['current_yield'] = float(current_yield)+ if ytm:+ metrics['yield_to_maturity'] = float(ytm)++ # Duration metrics+ duration_metrics = self.calculate_duration(ytm)+ for key, value in duration_metrics.items():+ metrics[key] = float(value)++ # Credit metrics+ credit_assessment = self.credit_risk_assessment()+ metrics.update(credit_assessment)++ # Price metrics+ metrics['current_price'] = float(self.current_price)+ metrics['nav'] = float(self.calculate_nav())++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive private debt valuation"""+ return {+ "debt_overview": {+ "asset_class": self.parameters.asset_class.value,+ "instrument_name": self.parameters.name,+ "principal_amount": float(self.principal_amount) if self.principal_amount else None,+ "seniority": self.seniority,+ "credit_rating": self.credit_rating+ },+ "performance_metrics": self.calculate_key_metrics(),+ "risk_assessment": self.credit_risk_assessment()+ }++ def interest_rate_sensitivity(self, rate_change_bps: int) -> Dict[str, Decimal]:+ """+ Calculate price sensitivity to interest rate changes+ CFA Standard: Duration-based price sensitivity+ """+ duration_metrics = self.calculate_duration()++ if 'modified_duration' not in duration_metrics:+ return {"error": "Cannot calculate duration"}++ modified_duration = duration_metrics['modified_duration']+ rate_change = Decimal(str(rate_change_bps)) / Constants.BASIS_POINTS++ # Price change approximation: ΔP/P ≈ -Modified Duration × Δy+ price_change_pct = -modified_duration * rate_change+ new_price = self.current_price * (Decimal('1') + price_change_pct)++ return {+ "rate_change_bps": Decimal(str(rate_change_bps)),+ "price_change_percent": price_change_pct,+ "new_price": new_price,+ "price_change_amount": new_price - self.current_price+ }+++class PrivateCapitalPortfolio:+ """+ Portfolio-level analysis for private capital investments+ CFA Standards: Portfolio construction and diversification+ """++ def __init__(self):+ self.pe_investments: List[PrivateEquityAnalyzer] = []+ self.pd_investments: List[PrivateDebtAnalyzer] = []++ def add_pe_investment(self, pe_investment: PrivateEquityAnalyzer) -> None:+ """Add private equity investment to portfolio"""+ self.pe_investments.append(pe_investment)++ def add_pd_investment(self, pd_investment: PrivateDebtAnalyzer) -> None:+ """Add private debt investment to portfolio"""+ self.pd_investments.append(pd_investment)++ def portfolio_summary(self) -> Dict[str, Any]:+ """Generate comprehensive portfolio summary"""+ total_nav = Decimal('0')+ total_commitments = Decimal('0')+ total_called = Decimal('0')+ total_distributed = Decimal('0')++ # PE Portfolio metrics+ pe_navs = []+ pe_irrs = []+ pe_moics = []++ for pe in self.pe_investments:+ nav = pe.calculate_nav()+ total_nav += nav+ pe_navs.append(nav)++ if pe.commitment:+ total_commitments += pe.commitment+ total_called += pe.called_capital+ total_distributed += pe.distributed_capital++ metrics = pe.calculate_key_metrics()+ if metrics.get('irr'):+ pe_irrs.append(Decimal(str(metrics['irr'])))+ if metrics.get('moic'):+ pe_moics.append(Decimal(str(metrics['moic'])))++ # PD Portfolio metrics+ pd_navs = []+ pd_yields = []++ for pd in self.pd_investments:+ nav = pd.calculate_nav()+ total_nav += nav+ pd_navs.append(nav)++ metrics = pd.calculate_key_metrics()+ if metrics.get('yield_to_maturity'):+ pd_yields.append(Decimal(str(metrics['yield_to_maturity'])))++ summary = {+ "portfolio_overview": {+ "total_nav": float(total_nav),+ "total_commitments": float(total_commitments),+ "total_called_capital": float(total_called),+ "total_distributions": float(total_distributed),+ "number_pe_investments": len(self.pe_investments),+ "number_pd_investments": len(self.pd_investments)+ },+ "pe_portfolio": {+ "average_irr": float(sum(pe_irrs) / len(pe_irrs)) if pe_irrs else None,+ "average_moic": float(sum(pe_moics) / len(pe_moics)) if pe_moics else None,+ "total_pe_nav": float(sum(pe_navs))+ },+ "pd_portfolio": {+ "average_yield": float(sum(pd_yields) / len(pd_yields)) if pd_yields else None,+ "total_pd_nav": float(sum(pd_navs))+ }+ }++ # Portfolio allocation+ if total_nav > 0:+ pe_allocation = sum(pe_navs) / total_nav+ pd_allocation = sum(pd_navs) / total_nav+ summary["allocation"] = {+ "pe_weight": float(pe_allocation),+ "pd_weight": float(pd_allocation)+ }++ return summary++ def diversification_analysis(self) -> Dict[str, Any]:+ """Analyze portfolio diversification"""+ analysis = {+ "vintage_year_diversification": {},+ "strategy_diversification": {},+ "geographic_diversification": {}+ }++ # Vintage year analysis for PE+ vintage_years = {}+ for pe in self.pe_investments:+ if pe.vintage_year:+ year = pe.vintage_year+ if year not in vintage_years:+ vintage_years[year] = []+ vintage_years[year].append(pe.calculate_nav())++ analysis["vintage_year_diversification"] = {+ year: {+ "count": len(investments),+ "total_nav": float(sum(investments))+ } for year, investments in vintage_years.items()+ }++ return analysis+++# Export main components+__all__ = ['PrivateEquityAnalyzer', 'PrivateDebtAnalyzer', 'PrivateCapitalPortfolio']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/real_estate.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/real_estate.pynew file mode 100644index 000000000..013d25b54--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/real_estate.py@@ -0,0 +1,704 @@+"""+Real Estate Analytics Module+============================++Comprehensive analysis framework for real estate investments including direct property investments, REITs, and infrastructure projects. Provides specialized valuation methodologies, income analysis, and portfolio management tools for real estate assets.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Property acquisition costs and current market values+ - Gross rental income and operating expense data+ - Vacancy rates and occupancy information+ - REIT financial statements (income statement, balance sheet)+ - Infrastructure project cash flow projections+ - Property type and regional market data++OUTPUT:+ - Net Operating Income (NOI) and capitalization rates+ - Direct capitalization and DCF valuations+ - REIT FFO, AFFO, and NAV per share calculations+ - Infrastructure project valuation with regulatory analysis+ - Portfolio diversification and geographic analysis++PARAMETERS:+ - property_type: Real estate property type (OFFICE, RETAIL, RESIDENTIAL, etc.)+ - acquisition_price: Property acquisition cost+ - current_market_value: Current property market value+ - gross_rental_income: Annual gross rental income+ - operating_expenses: Annual operating expenses+ - vacancy_rate: Vacancy rate percentage - default: 0.05 (5%)+ - cap_rate: Capitalization rate+ - shares_outstanding: REIT shares outstanding+ - infrastructure_type: Infrastructure asset type+ - regulatory_framework: Regulatory environment (regulated, merchant)+ - concession_period: Infrastructure concession period in years+ - revenue_model: Revenue model (user_pays, availability, hybrid)+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config, RealEstateType+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class RealEstateAnalyzer(AlternativeInvestmentBase):+ """+ Real Estate investment analysis and valuation+ CFA Standards: DCF, Direct Capitalization, Sales Comparison approaches+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.property_type = getattr(parameters, 'property_type', RealEstateType.OFFICE)+ self.acquisition_price = getattr(parameters, 'acquisition_price', None)+ self.current_market_value = getattr(parameters, 'current_market_value', None)+ self.gross_rental_income = getattr(parameters, 'gross_rental_income', None)+ self.operating_expenses = getattr(parameters, 'operating_expenses', None)+ self.vacancy_rate = getattr(parameters, 'vacancy_rate', Decimal('0.05')) # 5% default+ self.cap_rate = getattr(parameters, 'cap_rate', None)++ def calculate_noi(self) -> Decimal:+ """+ Calculate Net Operating Income+ CFA Standard: NOI = Gross Rental Income - Operating Expenses - Vacancy Loss+ """+ if not self.gross_rental_income:+ return Decimal('0')++ effective_gross_income = self.gross_rental_income * (Decimal('1') - self.vacancy_rate)+ operating_expenses = self.operating_expenses or Decimal('0')++ noi = effective_gross_income - operating_expenses+ return max(noi, Decimal('0'))++ def calculate_cap_rate(self, market_value: Decimal = None) -> Optional[Decimal]:+ """+ Calculate Capitalization Rate+ CFA Standard: Cap Rate = NOI / Property Value+ """+ noi = self.calculate_noi()+ value = market_value or self.current_market_value or self.acquisition_price++ if not value or value == 0 or noi <= 0:+ return None++ cap_rate = noi / value++ # Validate cap rate is within reasonable range+ if self.config.RE_CAP_RATE_MIN <= cap_rate <= self.config.RE_CAP_RATE_MAX:+ return cap_rate++ logger.warning(f"Calculated cap rate {cap_rate} outside normal range")+ return cap_rate++ def direct_capitalization_value(self, market_cap_rate: Decimal) -> Decimal:+ """+ Direct Capitalization valuation approach+ CFA Standard: Property Value = NOI / Cap Rate+ """+ noi = self.calculate_noi()++ if market_cap_rate <= 0:+ raise ValueError("Cap rate must be positive")++ return noi / market_cap_rate++ def dcf_valuation(self, projection_years: int = 10,+ terminal_cap_rate: Decimal = None,+ discount_rate: Decimal = None) -> Dict[str, Decimal]:+ """+ Discounted Cash Flow valuation+ CFA Standard: DCF approach for income-producing real estate+ """+ if not self.gross_rental_income:+ return {"error": "Gross rental income required for DCF"}++ if discount_rate is None:+ discount_rate = self.config.RISK_FREE_RATE + Decimal('0.04') # Add 4% risk premium++ if terminal_cap_rate is None:+ terminal_cap_rate = self.calculate_cap_rate() or Decimal('0.06')++ # Project cash flows+ current_noi = self.calculate_noi()+ annual_growth_rate = Decimal('0.03') # 3% annual growth assumption++ projected_cfs = []+ for year in range(1, projection_years + 1):+ projected_noi = current_noi * ((Decimal('1') + annual_growth_rate) ** year)+ projected_cfs.append(projected_noi)++ # Calculate terminal value+ terminal_noi = projected_cfs[-1] * (Decimal('1') + annual_growth_rate)+ terminal_value = terminal_noi / terminal_cap_rate++ # Discount cash flows to present value+ pv_cash_flows = Decimal('0')+ for year, cf in enumerate(projected_cfs, 1):+ pv = cf / ((Decimal('1') + discount_rate) ** year)+ pv_cash_flows += pv++ # Discount terminal value+ pv_terminal = terminal_value / ((Decimal('1') + discount_rate) ** projection_years)++ total_property_value = pv_cash_flows + pv_terminal++ return {+ "dcf_value": total_property_value,+ "pv_cash_flows": pv_cash_flows,+ "pv_terminal_value": pv_terminal,+ "terminal_value": terminal_value,+ "implied_cap_rate": current_noi / total_property_value if total_property_value > 0 else Decimal('0')+ }++ def calculate_real_estate_ratios(self) -> Dict[str, Decimal]:+ """Calculate key real estate financial ratios"""+ ratios = {}++ # Debt Service Coverage Ratio (if debt information available)+ noi = self.calculate_noi()++ # Operating Expense Ratio+ if self.gross_rental_income and self.operating_expenses:+ effective_gross = self.gross_rental_income * (Decimal('1') - self.vacancy_rate)+ expense_ratio = self.operating_expenses / effective_gross+ ratios['operating_expense_ratio'] = expense_ratio++ # NOI Margin+ if self.gross_rental_income:+ effective_gross = self.gross_rental_income * (Decimal('1') - self.vacancy_rate)+ noi_margin = noi / effective_gross if effective_gross > 0 else Decimal('0')+ ratios['noi_margin'] = noi_margin++ # Occupancy Rate+ occupancy_rate = Decimal('1') - self.vacancy_rate+ ratios['occupancy_rate'] = occupancy_rate++ return ratios++ def calculate_nav(self) -> Decimal:+ """Calculate current NAV based on market value or DCF"""+ if self.current_market_value:+ return self.current_market_value++ # Use DCF valuation as fallback+ dcf_result = self.dcf_valuation()+ if isinstance(dcf_result, dict) and 'dcf_value' in dcf_result:+ return dcf_result['dcf_value']++ return self.acquisition_price or Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key real estate metrics"""+ metrics = {}++ # Basic metrics+ noi = self.calculate_noi()+ metrics['noi'] = float(noi)++ cap_rate = self.calculate_cap_rate()+ if cap_rate:+ metrics['cap_rate'] = float(cap_rate)++ # Ratios+ ratios = self.calculate_real_estate_ratios()+ for key, value in ratios.items():+ metrics[key] = float(value)++ # Valuation metrics+ dcf_result = self.dcf_valuation()+ if isinstance(dcf_result, dict) and 'dcf_value' in dcf_result:+ metrics['dcf_valuation'] = float(dcf_result['dcf_value'])+ metrics['implied_cap_rate'] = float(dcf_result['implied_cap_rate'])++ # Performance metrics+ if self.acquisition_price and self.current_market_value:+ total_return = (self.current_market_value - self.acquisition_price) / self.acquisition_price+ metrics['capital_appreciation'] = float(total_return)++ # Income yield+ if self.current_market_value or self.acquisition_price:+ property_value = self.current_market_value or self.acquisition_price+ income_yield = noi / property_value if property_value > 0 else Decimal('0')+ metrics['income_yield'] = float(income_yield)++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive real estate valuation summary"""+ return {+ "property_overview": {+ "property_type": self.property_type.value,+ "acquisition_price": float(self.acquisition_price) if self.acquisition_price else None,+ "current_market_value": float(self.current_market_value) if self.current_market_value else None,+ "gross_rental_income": float(self.gross_rental_income) if self.gross_rental_income else None,+ "vacancy_rate": float(self.vacancy_rate)+ },+ "financial_metrics": self.calculate_key_metrics(),+ "valuation_approaches": {+ "direct_cap": float(self.direct_capitalization_value(self.cap_rate)) if self.cap_rate else None,+ "dcf": self.dcf_valuation()+ }+ }+++class REITAnalyzer(AlternativeInvestmentBase):+ """+ Real Estate Investment Trust (REIT) analysis+ CFA Standards: NAV, FFO, AFFO calculations and valuation+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.shares_outstanding = getattr(parameters, 'shares_outstanding', None)+ self.total_assets = getattr(parameters, 'total_assets', None)+ self.total_debt = getattr(parameters, 'total_debt', None)+ self.property_value = getattr(parameters, 'property_value', None)+ self.net_income = getattr(parameters, 'net_income', None)+ self.depreciation = getattr(parameters, 'depreciation', None)+ self.amortization = getattr(parameters, 'amortization', None)+ self.gains_on_sales = getattr(parameters, 'gains_on_sales', Decimal('0'))+ self.recurring_capex = getattr(parameters, 'recurring_capex', None)+ self.leasing_costs = getattr(parameters, 'leasing_costs', None)++ def calculate_ffo(self) -> Optional[Decimal]:+ """+ Calculate Funds From Operations+ CFA Standard: FFO = Net Income + Depreciation + Amortization - Gains on Sales+ """+ if not all([self.net_income, self.depreciation]):+ return None++ ffo = self.net_income + self.depreciation++ if self.amortization:+ ffo += self.amortization++ if self.gains_on_sales:+ ffo -= self.gains_on_sales++ return ffo++ def calculate_affo(self) -> Optional[Decimal]:+ """+ Calculate Adjusted Funds From Operations+ CFA Standard: AFFO = FFO - Recurring Capital Expenditures - Leasing Costs+ """+ ffo = self.calculate_ffo()++ if ffo is None:+ return None++ affo = ffo++ if self.recurring_capex:+ affo -= self.recurring_capex++ if self.leasing_costs:+ affo -= self.leasing_costs++ return affo++ def calculate_nav_per_share(self, property_values: Dict[str, Decimal] = None) -> Optional[Decimal]:+ """+ Calculate Net Asset Value per Share+ CFA Standard: NAVPS = (Total Property Value - Total Debt) / Shares Outstanding+ """+ if not self.shares_outstanding:+ return None++ # Use provided property values or estimated value+ total_property_value = self.property_value+ if property_values:+ total_property_value = sum(property_values.values())++ if not total_property_value:+ # Estimate using asset value+ total_property_value = self.total_assets or Decimal('0')++ total_debt = self.total_debt or Decimal('0')+ equity_value = total_property_value - total_debt++ navps = equity_value / self.shares_outstanding+ return navps++ def reit_valuation_ratios(self, current_share_price: Decimal) -> Dict[str, Optional[Decimal]]:+ """Calculate key REIT valuation ratios"""+ ratios = {}++ # Price-to-FFO ratio+ ffo = self.calculate_ffo()+ if ffo and self.shares_outstanding:+ ffo_per_share = ffo / self.shares_outstanding+ if ffo_per_share > 0:+ ratios['price_to_ffo'] = current_share_price / ffo_per_share+ ratios['ffo_per_share'] = ffo_per_share++ # Price-to-AFFO ratio+ affo = self.calculate_affo()+ if affo and self.shares_outstanding:+ affo_per_share = affo / self.shares_outstanding+ if affo_per_share > 0:+ ratios['price_to_affo'] = current_share_price / affo_per_share+ ratios['affo_per_share'] = affo_per_share++ # Price-to-NAV ratio+ navps = self.calculate_nav_per_share()+ if navps:+ ratios['price_to_nav'] = current_share_price / navps+ ratios['nav_per_share'] = navps++ # Debt-to-equity ratio+ if self.total_debt and self.property_value:+ equity_value = self.property_value - self.total_debt+ if equity_value > 0:+ ratios['debt_to_equity'] = self.total_debt / equity_value++ return ratios++ def dividend_analysis(self, annual_dividend: Decimal, current_price: Decimal) -> Dict[str, Decimal]:+ """Analyze REIT dividend metrics"""+ analysis = {}++ # Dividend yield+ dividend_yield = annual_dividend / current_price+ analysis['dividend_yield'] = dividend_yield++ # FFO payout ratio+ ffo = self.calculate_ffo()+ if ffo and self.shares_outstanding:+ total_dividends = annual_dividend * self.shares_outstanding+ ffo_payout_ratio = total_dividends / ffo+ analysis['ffo_payout_ratio'] = ffo_payout_ratio++ # AFFO payout ratio+ affo = self.calculate_affo()+ if affo and self.shares_outstanding:+ total_dividends = annual_dividend * self.shares_outstanding+ affo_payout_ratio = total_dividends / affo+ analysis['affo_payout_ratio'] = affo_payout_ratio++ return analysis++ def calculate_nav(self) -> Decimal:+ """Calculate REIT NAV"""+ navps = self.calculate_nav_per_share()+ if navps and self.shares_outstanding:+ return navps * self.shares_outstanding++ # Fallback to property value minus debt+ property_val = self.property_value or self.total_assets or Decimal('0')+ debt = self.total_debt or Decimal('0')+ return property_val - debt++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key REIT metrics"""+ metrics = {}++ # Core REIT metrics+ ffo = self.calculate_ffo()+ if ffo:+ metrics['ffo'] = float(ffo)+ if self.shares_outstanding:+ metrics['ffo_per_share'] = float(ffo / self.shares_outstanding)++ affo = self.calculate_affo()+ if affo:+ metrics['affo'] = float(affo)+ if self.shares_outstanding:+ metrics['affo_per_share'] = float(affo / self.shares_outstanding)++ navps = self.calculate_nav_per_share()+ if navps:+ metrics['nav_per_share'] = float(navps)++ # Financial ratios+ if self.total_debt and self.total_assets:+ debt_ratio = self.total_debt / self.total_assets+ metrics['debt_to_assets'] = float(debt_ratio)++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive REIT valuation summary"""+ return {+ "reit_overview": {+ "shares_outstanding": float(self.shares_outstanding) if self.shares_outstanding else None,+ "total_assets": float(self.total_assets) if self.total_assets else None,+ "total_debt": float(self.total_debt) if self.total_debt else None,+ "property_value": float(self.property_value) if self.property_value else None+ },+ "operating_metrics": self.calculate_key_metrics(),+ "valuation_metrics": {+ "ffo": float(self.calculate_ffo()) if self.calculate_ffo() else None,+ "affo": float(self.calculate_affo()) if self.calculate_affo() else None,+ "nav_per_share": float(self.calculate_nav_per_share()) if self.calculate_nav_per_share() else None+ }+ }+++class InfrastructureAnalyzer(AlternativeInvestmentBase):+ """+ Infrastructure investment analysis+ CFA Standards: Project finance, regulated utility analysis+ """++ def __init__(self, parameters: AssetParameters):+ super().__init__(parameters)+ self.infrastructure_type = getattr(parameters, 'infrastructure_type', 'transportation')+ self.regulatory_framework = getattr(parameters, 'regulatory_framework', 'regulated')+ self.concession_period = getattr(parameters, 'concession_period', None) # years+ self.revenue_model = getattr(parameters, 'revenue_model', 'user_pays') # user_pays, availability, hybrid+ self.annual_revenue = getattr(parameters, 'annual_revenue', None)+ self.operating_costs = getattr(parameters, 'operating_costs', None)+ self.maintenance_capex = getattr(parameters, 'maintenance_capex', None)+ self.inflation_indexation = getattr(parameters, 'inflation_indexation', True)++ def project_cash_flows(self, projection_years: int = None) -> List[Dict[str, Decimal]]:+ """+ Project infrastructure cash flows+ CFA Standard: DCF for infrastructure projects+ """+ if projection_years is None:+ projection_years = self.concession_period or 25++ if not self.annual_revenue:+ return []++ cash_flows = []+ inflation_rate = Decimal('0.025') # 2.5% annual inflation++ for year in range(1, projection_years + 1):+ # Escalate revenues and costs for inflation+ if self.inflation_indexation:+ revenue = self.annual_revenue * ((Decimal('1') + inflation_rate) ** (year - 1))+ opex = (self.operating_costs or Decimal('0')) * ((Decimal('1') + inflation_rate) ** (year - 1))+ maintenance = (self.maintenance_capex or Decimal('0')) * ((Decimal('1') + inflation_rate) ** (year - 1))+ else:+ revenue = self.annual_revenue+ opex = self.operating_costs or Decimal('0')+ maintenance = self.maintenance_capex or Decimal('0')++ ebitda = revenue - opex+ free_cash_flow = ebitda - maintenance++ cash_flows.append({+ 'year': year,+ 'revenue': revenue,+ 'operating_costs': opex,+ 'maintenance_capex': maintenance,+ 'ebitda': ebitda,+ 'free_cash_flow': free_cash_flow+ })++ return cash_flows++ def infrastructure_valuation(self, discount_rate: Decimal = None) -> Dict[str, Decimal]:+ """+ Value infrastructure investment using DCF+ """+ if discount_rate is None:+ # Infrastructure typically uses lower discount rates due to stable cash flows+ discount_rate = self.config.RISK_FREE_RATE + Decimal('0.03') # 3% risk premium++ projected_cfs = self.project_cash_flows()++ if not projected_cfs:+ return {"error": "Cannot project cash flows"}++ present_value = Decimal('0')++ for cf in projected_cfs:+ year = cf['year']+ fcf = cf['free_cash_flow']+ pv = fcf / ((Decimal('1') + discount_rate) ** year)+ present_value += pv++ return {+ "enterprise_value": present_value,+ "discount_rate": discount_rate,+ "projection_years": len(projected_cfs),+ "terminal_year_fcf": projected_cfs[-1]['free_cash_flow'] if projected_cfs else Decimal('0')+ }++ def regulatory_risk_assessment(self) -> Dict[str, Any]:+ """Assess regulatory risk factors"""+ risk_factors = {+ "regulatory_framework": self.regulatory_framework,+ "concession_period": self.concession_period,+ "revenue_model": self.revenue_model,+ "inflation_protection": self.inflation_indexation+ }++ # Risk scoring (simplified)+ risk_score = 0++ if self.regulatory_framework == 'regulated':+ risk_score += 1 # Lower risk+ elif self.regulatory_framework == 'merchant':+ risk_score += 3 # Higher risk++ if self.revenue_model == 'availability':+ risk_score += 1 # Lower demand risk+ elif self.revenue_model == 'user_pays':+ risk_score += 2 # Higher demand risk++ if not self.inflation_indexation:+ risk_score += 1 # Additional inflation risk++ risk_factors['risk_score'] = risk_score+ risk_factors['risk_level'] = 'Low' if risk_score <= 3 else 'Medium' if risk_score <= 5 else 'High'++ return risk_factors++ def calculate_nav(self) -> Decimal:+ """Calculate infrastructure NAV using DCF"""+ valuation = self.infrastructure_valuation()+ if isinstance(valuation, dict) and 'enterprise_value' in valuation:+ return valuation['enterprise_value']+ return Decimal('0')++ def calculate_key_metrics(self) -> Dict[str, Any]:+ """Calculate key infrastructure metrics"""+ metrics = {}++ # Valuation metrics+ valuation = self.infrastructure_valuation()+ if isinstance(valuation, dict):+ for key, value in valuation.items():+ if isinstance(value, Decimal):+ metrics[key] = float(value)+ else:+ metrics[key] = value++ # Operating metrics+ if self.annual_revenue and self.operating_costs:+ ebitda_margin = (self.annual_revenue - self.operating_costs) / self.annual_revenue+ metrics['ebitda_margin'] = float(ebitda_margin)++ # Risk assessment+ risk_assessment = self.regulatory_risk_assessment()+ metrics.update(risk_assessment)++ return metrics++ def valuation_summary(self) -> Dict[str, Any]:+ """Comprehensive infrastructure valuation summary"""+ return {+ "infrastructure_overview": {+ "infrastructure_type": self.infrastructure_type,+ "regulatory_framework": self.regulatory_framework,+ "revenue_model": self.revenue_model,+ "concession_period": self.concession_period,+ "inflation_indexation": self.inflation_indexation+ },+ "financial_projections": self.project_cash_flows(),+ "valuation_analysis": self.infrastructure_valuation(),+ "risk_assessment": self.regulatory_risk_assessment()+ }+++class RealEstatePortfolio:+ """+ Portfolio-level real estate analysis+ CFA Standards: Portfolio diversification and risk management+ """++ def __init__(self):+ self.real_estate_investments: List[RealEstateAnalyzer] = []+ self.reit_investments: List[REITAnalyzer] = []+ self.infrastructure_investments: List[InfrastructureAnalyzer] = []++ def add_real_estate(self, investment: RealEstateAnalyzer) -> None:+ """Add direct real estate investment"""+ self.real_estate_investments.append(investment)++ def add_reit(self, reit: REITAnalyzer) -> None:+ """Add REIT investment"""+ self.reit_investments.append(reit)++ def add_infrastructure(self, infrastructure: InfrastructureAnalyzer) -> None:+ """Add infrastructure investment"""+ self.infrastructure_investments.append(infrastructure)++ def portfolio_summary(self) -> Dict[str, Any]:+ """Generate comprehensive real estate portfolio summary"""+ total_nav = Decimal('0')++ # Direct real estate+ re_navs = [inv.calculate_nav() for inv in self.real_estate_investments]+ re_total = sum(re_navs)+ total_nav += re_total++ # REITs+ reit_navs = [reit.calculate_nav() for reit in self.reit_investments]+ reit_total = sum(reit_navs)+ total_nav += reit_total++ # Infrastructure+ infra_navs = [infra.calculate_nav() for infra in self.infrastructure_investments]+ infra_total = sum(infra_navs)+ total_nav += infra_total++ summary = {+ "portfolio_overview": {+ "total_portfolio_nav": float(total_nav),+ "direct_real_estate_count": len(self.real_estate_investments),+ "reit_count": len(self.reit_investments),+ "infrastructure_count": len(self.infrastructure_investments)+ },+ "allocation": {+ "direct_real_estate": {+ "nav": float(re_total),+ "weight": float(re_total / total_nav) if total_nav > 0 else 0+ },+ "reits": {+ "nav": float(reit_total),+ "weight": float(reit_total / total_nav) if total_nav > 0 else 0+ },+ "infrastructure": {+ "nav": float(infra_total),+ "weight": float(infra_total / total_nav) if total_nav > 0 else 0+ }+ }+ }++ return summary++ def geographic_diversification(self) -> Dict[str, Any]:+ """Analyze geographic diversification"""+ # Simplified geographic analysis+ regions = {}++ for inv in self.real_estate_investments:+ region = getattr(inv.parameters, 'region', 'Unknown')+ if region not in regions:+ regions[region] = []+ regions[region].append(inv.calculate_nav())++ diversification = {}+ total_value = sum(sum(navs) for navs in regions.values())++ for region, navs in regions.items():+ region_value = sum(navs)+ diversification[region] = {+ "count": len(navs),+ "total_value": float(region_value),+ "weight": float(region_value / total_value) if total_value > 0 else 0+ }++ return diversification+++# Export main components+__all__ = ['RealEstateAnalyzer', 'REITAnalyzer', 'InfrastructureAnalyzer', 'RealEstatePortfolio']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/risk_analyzer.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/risk_analyzer.pynew file mode 100644index 000000000..a33b3bd31--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/alternateInvestment/risk_analyzer.py@@ -0,0 +1,1409 @@+"""+Alternative Investment Risk Analyzer Module+==========================================++Comprehensive risk management framework for alternative investments including VaR analysis, stress testing, correlation analysis, liquidity risk assessment, and portfolio-level risk analytics. Implements CFA Institute standard risk measurement methodologies.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical return series for alternative investments+ - Market data and price histories+ - Trading volumes and market capitalization data+ - Bid-ask spreads and liquidity metrics+ - Factor returns for multi-factor risk models+ - Portfolio weights and asset classifications++OUTPUT:+ - Value at Risk (VaR) calculations using multiple methods+ - Conditional VaR and tail risk analysis+ - Stress testing and scenario analysis results+ - Correlation matrices and diversification metrics+ - Liquidity risk assessment and scoring+ - Portfolio-level risk attribution and budgeting++PARAMETERS:+ - confidence_levels: VaR confidence levels - default: [0.01, 0.05, 0.10]+ - rolling_window: Window size for rolling correlations - default: 60+ - asset_class: Asset class for specific risk scenarios+ - portfolio_weights: Portfolio allocation weights+ - stress_scenarios: Custom stress scenario parameters+ - target_risk_budgets: Risk budget allocations by asset+ - num_simulations: Number of Monte Carlo simulations - default: 1000+"""++import numpy as np+import pandas as pd+from decimal import Decimal, getcontext+from typing import List, Dict, Optional, Any, Tuple, Union+from datetime import datetime, timedelta+import logging++from config import (+ MarketData, CashFlow, Performance, AssetParameters, AssetClass,+ Constants, Config+)+from base_analytics import AlternativeInvestmentBase, FinancialMath++logger = logging.getLogger(__name__)+++class RiskAnalyzer:+ """+ Comprehensive risk analysis for alternative investments+ CFA Standards: Risk measurement, stress testing, scenario analysis+ """++ def __init__(self):+ self.math = FinancialMath()+ self.config = Config()++ def value_at_risk_analysis(self, returns: List[Decimal],+ confidence_levels: List[Decimal] = None) -> Dict[str, Any]:+ """+ Comprehensive Value at Risk analysis+ CFA Standard: Historical simulation, parametric, and Monte Carlo VaR+ """+ if not returns:+ return {"error": "No return data provided"}++ if confidence_levels is None:+ confidence_levels = [Decimal('0.01'), Decimal('0.05'), Decimal('0.10')]++ var_analysis = {}++ # Historical VaR+ historical_var = {}+ for confidence in confidence_levels:+ var_value = self.math.var_historical(returns, confidence)+ confidence_pct = int((1 - confidence) * 100)+ historical_var[f"var_{confidence_pct}"] = float(var_value)++ var_analysis['historical_var'] = historical_var++ # Parametric VaR (assuming normal distribution)+ mean_return = sum(returns) / len(returns)+ volatility = self._calculate_volatility(returns)++ parametric_var = {}+ for confidence in confidence_levels:+ # Z-score for confidence level+ z_scores = {+ Decimal('0.01'): Decimal('-2.326'), # 99% confidence+ Decimal('0.05'): Decimal('-1.645'), # 95% confidence+ Decimal('0.10'): Decimal('-1.282') # 90% confidence+ }++ z_score = z_scores.get(confidence, Decimal('-1.645'))+ var_value = mean_return + z_score * volatility+ confidence_pct = int((1 - confidence) * 100)+ parametric_var[f"var_{confidence_pct}"] = float(abs(var_value))++ var_analysis['parametric_var'] = parametric_var++ # Conditional VaR (Expected Shortfall)+ conditional_var = {}+ for confidence in confidence_levels:+ cvar_value = self._calculate_conditional_var(returns, confidence)+ confidence_pct = int((1 - confidence) * 100)+ conditional_var[f"cvar_{confidence_pct}"] = float(cvar_value)++ var_analysis['conditional_var'] = conditional_var++ # VaR model comparison+ var_analysis['model_comparison'] = self._compare_var_models(+ historical_var, parametric_var, returns+ )++ return var_analysis++ def stress_testing(self, returns: List[Decimal],+ asset_class: AssetClass = None) -> Dict[str, Any]:+ """+ Comprehensive stress testing framework+ CFA Standard: Scenario analysis and stress testing+ """+ if not returns:+ return {"error": "No return data provided"}++ stress_results = {}++ # Historical stress scenarios+ historical_scenarios = self._historical_stress_scenarios(returns)+ stress_results['historical_scenarios'] = historical_scenarios++ # Hypothetical stress scenarios+ hypothetical_scenarios = self._hypothetical_stress_scenarios(returns, asset_class)+ stress_results['hypothetical_scenarios'] = hypothetical_scenarios++ # Monte Carlo stress testing+ monte_carlo_scenarios = self._monte_carlo_stress_testing(returns)+ stress_results['monte_carlo_scenarios'] = monte_carlo_scenarios++ # Tail risk analysis+ tail_risk = self._analyze_tail_risk(returns)+ stress_results['tail_risk_analysis'] = tail_risk++ return stress_results++ def correlation_analysis(self, asset_returns: Dict[str, List[Decimal]],+ rolling_window: int = 60) -> Dict[str, Any]:+ """+ Dynamic correlation analysis across asset classes+ CFA Standard: Correlation analysis and diversification benefits+ """+ if len(asset_returns) < 2:+ return {"error": "Need at least 2 asset return series"}++ correlation_analysis = {}++ # Static correlation matrix+ static_correlations = self._calculate_correlation_matrix(asset_returns)+ correlation_analysis['static_correlations'] = static_correlations++ # Rolling correlations+ rolling_correlations = self._calculate_rolling_correlations(+ asset_returns, rolling_window+ )+ correlation_analysis['rolling_correlations'] = rolling_correlations++ # Correlation breakdown analysis+ correlation_breakdown = self._analyze_correlation_breakdown(asset_returns)+ correlation_analysis['correlation_breakdown'] = correlation_breakdown++ # Diversification effectiveness+ diversification_metrics = self._calculate_diversification_metrics(static_correlations)+ correlation_analysis['diversification_metrics'] = diversification_metrics++ return correlation_analysis++ def liquidity_risk_assessment(self, trading_volumes: List[Decimal],+ market_caps: List[Decimal] = None,+ bid_ask_spreads: List[Decimal] = None) -> Dict[str, Any]:+ """+ Comprehensive liquidity risk assessment+ CFA Standard: Liquidity risk measurement and management+ """+ liquidity_assessment = {}++ if not trading_volumes:+ return {"error": "Trading volume data required"}++ # Volume-based liquidity metrics+ volume_metrics = self._analyze_volume_patterns(trading_volumes)+ liquidity_assessment['volume_metrics'] = volume_metrics++ # Market impact estimation+ if market_caps:+ market_impact = self._estimate_market_impact(trading_volumes, market_caps)+ liquidity_assessment['market_impact'] = market_impact++ # Bid-ask spread analysis+ if bid_ask_spreads:+ spread_analysis = self._analyze_bid_ask_spreads(bid_ask_spreads)+ liquidity_assessment['spread_analysis'] = spread_analysis++ # Liquidity scoring+ liquidity_score = self._calculate_liquidity_score(+ volume_metrics, market_caps, bid_ask_spreads+ )+ liquidity_assessment['liquidity_score'] = liquidity_score++ return liquidity_assessment++ def drawdown_analysis(self, price_series: List[Decimal]) -> Dict[str, Any]:+ """+ Comprehensive drawdown analysis+ CFA Standard: Drawdown measurement and recovery analysis+ """+ if len(price_series) < 2:+ return {"error": "Insufficient price data"}++ drawdown_results = {}++ # Calculate drawdown series+ drawdowns = self._calculate_drawdown_series(price_series)++ # Maximum drawdown+ max_dd, peak_idx, trough_idx = self.math.maximum_drawdown(price_series)+ drawdown_results['maximum_drawdown'] = float(max_dd)+ drawdown_results['peak_to_trough_periods'] = trough_idx - peak_idx++ # Drawdown statistics+ dd_stats = self._calculate_drawdown_statistics(drawdowns)+ drawdown_results['drawdown_statistics'] = dd_stats++ # Recovery analysis+ recovery_analysis = self._analyze_recovery_patterns(price_series, drawdowns)+ drawdown_results['recovery_analysis'] = recovery_analysis++ # Ulcer Index (alternative drawdown measure)+ ulcer_index = self._calculate_ulcer_index(drawdowns)+ drawdown_results['ulcer_index'] = float(ulcer_index)++ return drawdown_results++ def risk_attribution(self, portfolio_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]]) -> Dict[str, Any]:+ """+ Risk attribution analysis using factor models+ CFA Standard: Risk factor decomposition+ """+ if not portfolio_returns or not factor_returns:+ return {"error": "Portfolio returns and factor returns required"}++ attribution_results = {}++ # Factor exposure calculation+ factor_exposures = self._calculate_factor_exposures(portfolio_returns, factor_returns)+ attribution_results['factor_exposures'] = factor_exposures++ # Risk contribution by factor+ risk_contributions = self._calculate_risk_contributions(+ portfolio_returns, factor_returns, factor_exposures+ )+ attribution_results['risk_contributions'] = risk_contributions++ # Idiosyncratic risk+ idiosyncratic_risk = self._calculate_idiosyncratic_risk(+ portfolio_returns, factor_returns, factor_exposures+ )+ attribution_results['idiosyncratic_risk'] = float(idiosyncratic_risk)++ return attribution_results++ def scenario_analysis(self, base_returns: List[Decimal],+ scenarios: Dict[str, Dict[str, Decimal]]) -> Dict[str, Any]:+ """+ Comprehensive scenario analysis+ CFA Standard: Scenario planning and sensitivity analysis+ """+ scenario_results = {}++ for scenario_name, scenario_params in scenarios.items():+ scenario_impact = self._calculate_scenario_impact(base_returns, scenario_params)+ scenario_results[scenario_name] = scenario_impact++ # Best/worst case analysis+ scenario_summary = self._summarize_scenario_outcomes(scenario_results)+ scenario_results['scenario_summary'] = scenario_summary++ return scenario_results++ # Helper methods++ def _calculate_volatility(self, returns: List[Decimal]) -> Decimal:+ """Calculate standard deviation of returns"""+ if len(returns) < 2:+ return Decimal('0')++ mean_return = sum(returns) / len(returns)+ variance = sum((r - mean_return) ** 2 for r in returns) / (len(returns) - 1)+ return variance.sqrt()++ def _calculate_conditional_var(self, returns: List[Decimal], confidence: Decimal) -> Decimal:+ """Calculate Conditional VaR (Expected Shortfall)"""+ if not returns:+ return Decimal('0')++ sorted_returns = sorted(returns)+ var_index = int(len(sorted_returns) * confidence)++ if var_index >= len(sorted_returns):+ var_index = len(sorted_returns) - 1++ # Average of returns at or below VaR level+ tail_returns = sorted_returns[:var_index + 1]+ if not tail_returns:+ return Decimal('0')++ cvar = sum(tail_returns) / len(tail_returns)+ return abs(cvar)++ def _compare_var_models(self, historical_var: Dict, parametric_var: Dict,+ returns: List[Decimal]) -> Dict[str, Any]:+ """Compare different VaR model approaches"""+ comparison = {}++ # Model accuracy assessment (simplified)+ for confidence_key in historical_var.keys():+ hist_var = historical_var[confidence_key]+ param_var = parametric_var[confidence_key]++ difference = abs(hist_var - param_var)+ relative_difference = difference / hist_var if hist_var != 0 else 0++ comparison[confidence_key] = {+ 'historical_var': hist_var,+ 'parametric_var': param_var,+ 'absolute_difference': difference,+ 'relative_difference': relative_difference+ }++ # Recommend preferred model+ avg_relative_diff = sum(comp['relative_difference'] for comp in comparison.values()) / len(comparison)++ if avg_relative_diff < 0.1: # Less than 10% difference+ comparison['recommended_model'] = 'Either (similar results)'+ elif len(returns) < 100:+ comparison['recommended_model'] = 'Parametric (limited history)'+ else:+ comparison['recommended_model'] = 'Historical (sufficient data)'++ return comparison++ def _historical_stress_scenarios(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze historical stress periods"""+ if len(returns) < 20:+ return {"insufficient_data": True}++ # Identify worst periods+ worst_returns = sorted(returns)[:10] # Worst 10 returns++ # Calculate impact of worst historical scenarios+ scenarios = {}++ # Single worst day+ scenarios['worst_single_period'] = {+ 'return': float(worst_returns[0]),+ 'impact': f"{float(worst_returns[0] * 100):.2f}%"+ }++ # Worst consecutive periods (simplified)+ worst_consecutive = self._find_worst_consecutive_periods(returns, 5)+ scenarios['worst_5_period_sequence'] = {+ 'cumulative_return': float(worst_consecutive),+ 'impact': f"{float(worst_consecutive * 100):.2f}%"+ }++ return scenarios++ def _hypothetical_stress_scenarios(self, returns: List[Decimal],+ asset_class: AssetClass = None) -> Dict[str, Any]:+ """Generate hypothetical stress scenarios"""+ scenarios = {}++ # Standard stress scenarios+ current_vol = self._calculate_volatility(returns)++ # 2-standard deviation move+ two_sigma_shock = current_vol * Decimal('2')+ scenarios['two_sigma_shock'] = {+ 'negative_shock': float(-two_sigma_shock),+ 'positive_shock': float(two_sigma_shock)+ }++ # Asset class specific scenarios+ if asset_class:+ asset_scenarios = self._get_asset_class_scenarios(asset_class)+ scenarios.update(asset_scenarios)++ return scenarios++ def _monte_carlo_stress_testing(self, returns: List[Decimal],+ num_simulations: int = 1000) -> Dict[str, Any]:+ """Monte Carlo stress testing"""+ if len(returns) < 10:+ return {"insufficient_data": True}++ mean_return = sum(returns) / len(returns)+ volatility = self._calculate_volatility(returns)++ # Generate random scenarios+ simulated_outcomes = []++ # Simplified Monte Carlo (normal distribution assumption)+ try:+ import random+ random.seed(42) # For reproducible results++ for _ in range(num_simulations):+ # Generate random normal variable+ z = Decimal(str(random.gauss(0, 1)))+ simulated_return = mean_return + volatility * z+ simulated_outcomes.append(simulated_return)+ except ImportError:+ # Fallback if random module not available+ for i in range(num_simulations):+ # Simple deterministic simulation+ z = Decimal(str((i - num_simulations / 2) / (num_simulations / 4)))+ simulated_return = mean_return + volatility * z+ simulated_outcomes.append(simulated_return)++ # Analyze outcomes+ sorted_outcomes = sorted(simulated_outcomes)++ return {+ 'worst_1_percent': float(sorted_outcomes[int(0.01 * len(sorted_outcomes))]),+ 'worst_5_percent': float(sorted_outcomes[int(0.05 * len(sorted_outcomes))]),+ 'best_5_percent': float(sorted_outcomes[int(0.95 * len(sorted_outcomes))]),+ 'median_outcome': float(sorted_outcomes[len(sorted_outcomes) // 2]),+ 'simulations_run': num_simulations+ }++ def _analyze_tail_risk(self, returns: List[Decimal]) -> Dict[str, Any]:+ """Analyze tail risk characteristics"""+ if len(returns) < 20:+ return {"insufficient_data": True}++ sorted_returns = sorted(returns)++ # Tail ratios+ left_tail_10pct = sorted_returns[:len(returns) // 10]+ right_tail_10pct = sorted_returns[-len(returns) // 10:]++ left_tail_mean = sum(left_tail_10pct) / len(left_tail_10pct) if left_tail_10pct else Decimal('0')+ right_tail_mean = sum(right_tail_10pct) / len(right_tail_10pct) if right_tail_10pct else Decimal('0')++ return {+ 'left_tail_mean': float(left_tail_mean),+ 'right_tail_mean': float(right_tail_mean),+ 'tail_ratio': float(abs(left_tail_mean / right_tail_mean)) if right_tail_mean != 0 else 0,+ 'skewness_indicator': 'negative_skew' if abs(left_tail_mean) > right_tail_mean else 'positive_skew'+ }++ def _calculate_correlation_matrix(self, asset_returns: Dict[str, List[Decimal]]) -> Dict[str, Dict[str, float]]:+ """Calculate static correlation matrix"""+ assets = list(asset_returns.keys())+ correlation_matrix = {}++ for asset1 in assets:+ correlation_matrix[asset1] = {}+ for asset2 in assets:+ if asset1 == asset2:+ correlation_matrix[asset1][asset2] = 1.0+ else:+ returns1 = asset_returns[asset1]+ returns2 = asset_returns[asset2]++ if len(returns1) == len(returns2) and len(returns1) > 1:+ correlation = self._calculate_correlation(returns1, returns2)+ correlation_matrix[asset1][asset2] = float(correlation)+ else:+ correlation_matrix[asset1][asset2] = 0.0++ return correlation_matrix++ def _calculate_rolling_correlations(self, asset_returns: Dict[str, List[Decimal]],+ window: int) -> Dict[str, List[float]]:+ """Calculate rolling correlations between assets"""+ rolling_correlations = {}++ assets = list(asset_returns.keys())+ if len(assets) < 2:+ return rolling_correlations++ # Take first two assets for primary rolling correlation+ asset1, asset2 = assets[0], assets[1]+ returns1 = asset_returns[asset1]+ returns2 = asset_returns[asset2]++ if len(returns1) != len(returns2) or len(returns1) < window:+ return rolling_correlations++ correlations = []+ for i in range(window, len(returns1)):+ window_returns1 = returns1[i - window:i]+ window_returns2 = returns2[i - window:i]++ correlation = self._calculate_correlation(window_returns1, window_returns2)+ correlations.append(float(correlation))++ rolling_correlations[f"{asset1}_vs_{asset2}"] = correlations++ return rolling_correlations++ def _calculate_correlation(self, returns1: List[Decimal], returns2: List[Decimal]) -> Decimal:+ """Calculate correlation coefficient"""+ if len(returns1) != len(returns2) or len(returns1) < 2:+ return Decimal('0')++ mean1 = sum(returns1) / len(returns1)+ mean2 = sum(returns2) / len(returns2)++ numerator = sum((r1 - mean1) * (r2 - mean2) for r1, r2 in zip(returns1, returns2))++ sum_sq1 = sum((r1 - mean1) ** 2 for r1 in returns1)+ sum_sq2 = sum((r2 - mean2) ** 2 for r2 in returns2)++ denominator = (sum_sq1 * sum_sq2).sqrt()++ if denominator == 0:+ return Decimal('0')++ return numerator / denominator++ def _analyze_correlation_breakdown(self, asset_returns: Dict[str, List[Decimal]]) -> Dict[str, Any]:+ """Analyze correlation breakdown during stress periods"""+ breakdown_analysis = {}++ assets = list(asset_returns.keys())+ if len(assets) < 2:+ return breakdown_analysis++ # Calculate average correlations+ all_correlations = []+ correlation_matrix = self._calculate_correlation_matrix(asset_returns)++ for asset1 in assets:+ for asset2 in assets:+ if asset1 != asset2:+ corr = correlation_matrix[asset1][asset2]+ all_correlations.append(corr)++ if all_correlations:+ avg_correlation = sum(all_correlations) / len(all_correlations)+ breakdown_analysis['average_correlation'] = avg_correlation++ if avg_correlation > 0.7:+ breakdown_analysis['diversification_benefit'] = 'Low'+ elif avg_correlation > 0.4:+ breakdown_analysis['diversification_benefit'] = 'Medium'+ else:+ breakdown_analysis['diversification_benefit'] = 'High'++ return breakdown_analysis++ def _calculate_diversification_metrics(self, correlation_matrix: Dict[str, Dict[str, float]]) -> Dict[str, Any]:+ """Calculate diversification effectiveness metrics"""+ assets = list(correlation_matrix.keys())++ if len(assets) < 2:+ return {}++ # Calculate average correlation+ all_correlations = []+ for asset1 in assets:+ for asset2 in assets:+ if asset1 != asset2:+ all_correlations.append(correlation_matrix[asset1][asset2])++ avg_correlation = sum(all_correlations) / len(all_correlations) if all_correlations else 0++ # Diversification ratio (simplified)+ # Perfect diversification would have correlation = 0+ diversification_effectiveness = 1 - abs(avg_correlation)++ return {+ 'average_correlation': avg_correlation,+ 'diversification_effectiveness': diversification_effectiveness,+ 'number_of_assets': len(assets)+ }++ def _analyze_volume_patterns(self, volumes: List[Decimal]) -> Dict[str, Any]:+ """Analyze trading volume patterns for liquidity assessment"""+ if not volumes:+ return {}++ avg_volume = sum(volumes) / len(volumes)+ volume_volatility = self._calculate_volatility(volumes)++ # Volume stability+ volume_stability = 1 - (volume_volatility / avg_volume) if avg_volume > 0 else 0++ return {+ 'average_volume': float(avg_volume),+ 'volume_volatility': float(volume_volatility),+ 'volume_stability': float(volume_stability)+ }++ def _estimate_market_impact(self, volumes: List[Decimal], market_caps: List[Decimal]) -> Dict[str, Any]:+ """Estimate market impact for liquidity assessment"""+ if len(volumes) != len(market_caps):+ return {}++ # Calculate volume to market cap ratios+ volume_ratios = []+ for vol, mcap in zip(volumes, market_caps):+ if mcap > 0:+ ratio = vol / mcap+ volume_ratios.append(ratio)++ if not volume_ratios:+ return {}++ avg_volume_ratio = sum(volume_ratios) / len(volume_ratios)++ # Estimate market impact (simplified)+ if avg_volume_ratio > Decimal('0.1'):+ impact_assessment = 'Low'+ elif avg_volume_ratio > Decimal('0.01'):+ impact_assessment = 'Medium'+ else:+ impact_assessment = 'High'++ return {+ 'average_volume_to_mcap': float(avg_volume_ratio),+ 'market_impact_assessment': impact_assessment+ }++ def _analyze_bid_ask_spreads(self, spreads: List[Decimal]) -> Dict[str, Any]:+ """Analyze bid-ask spreads for liquidity assessment"""+ if not spreads:+ return {}++ avg_spread = sum(spreads) / len(spreads)+ spread_volatility = self._calculate_volatility(spreads)++ return {+ 'average_spread': float(avg_spread),+ 'spread_volatility': float(spread_volatility),+ 'spread_stability': float(1 - (spread_volatility / avg_spread)) if avg_spread > 0 else 0+ }++ def _calculate_liquidity_score(self, volume_metrics: Dict, market_caps: List[Decimal],+ bid_ask_spreads: List[Decimal]) -> Dict[str, Any]:+ """Calculate composite liquidity score"""+ score_components = {}+ total_score = 0+ components_count = 0++ # Volume component+ if volume_metrics and 'volume_stability' in volume_metrics:+ volume_score = volume_metrics['volume_stability'] * 100+ score_components['volume_score'] = volume_score+ total_score += volume_score+ components_count += 1++ # Market cap component (simplified)+ if market_caps:+ avg_mcap = sum(market_caps) / len(market_caps)+ # Larger market cap generally means better liquidity+ mcap_score = min(100, float(avg_mcap) / 1000000) # Scale to 0-100+ score_components['market_cap_score'] = mcap_score+ total_score += mcap_score+ components_count += 1++ # Spread component+ if bid_ask_spreads:+ avg_spread = sum(bid_ask_spreads) / len(bid_ask_spreads)+ # Lower spreads mean better liquidity+ spread_score = max(0, 100 - float(avg_spread * 10000)) # Convert to basis points+ score_components['spread_score'] = spread_score+ total_score += spread_score+ components_count += 1++ composite_score = total_score / components_count if components_count > 0 else 0++ return {+ 'composite_liquidity_score': composite_score,+ 'score_components': score_components,+ 'liquidity_rating': self._get_liquidity_rating(composite_score)+ }++ def _get_liquidity_rating(self, score: float) -> str:+ """Convert liquidity score to rating"""+ if score >= 80:+ return 'Excellent'+ elif score >= 60:+ return 'Good'+ elif score >= 40:+ return 'Fair'+ elif score >= 20:+ return 'Poor'+ else:+ return 'Very Poor'++ def _calculate_drawdown_series(self, price_series: List[Decimal]) -> List[Decimal]:+ """Calculate drawdown series from price series"""+ if not price_series:+ return []++ drawdowns = []+ peak = price_series[0]++ for price in price_series:+ if price > peak:+ peak = price++ drawdown = (peak - price) / peak+ drawdowns.append(drawdown)++ return drawdowns++ def _calculate_drawdown_statistics(self, drawdowns: List[Decimal]) -> Dict[str, Any]:+ """Calculate comprehensive drawdown statistics"""+ if not drawdowns:+ return {}++ # Basic statistics+ max_dd = max(drawdowns)+ avg_dd = sum(drawdowns) / len(drawdowns)++ # Drawdown frequency (periods in drawdown)+ periods_in_drawdown = sum(1 for dd in drawdowns if dd > 0)+ drawdown_frequency = periods_in_drawdown / len(drawdowns)++ return {+ 'maximum_drawdown': float(max_dd),+ 'average_drawdown': float(avg_dd),+ 'drawdown_frequency': float(drawdown_frequency),+ 'periods_in_drawdown': periods_in_drawdown,+ 'total_periods': len(drawdowns)+ }++ def _analyze_recovery_patterns(self, price_series: List[Decimal],+ drawdowns: List[Decimal]) -> Dict[str, Any]:+ """Analyze recovery patterns from drawdowns"""+ if len(price_series) != len(drawdowns):+ return {}++ recovery_periods = []+ in_drawdown = False+ drawdown_start = 0++ for i, dd in enumerate(drawdowns):+ if dd > 0 and not in_drawdown:+ # Start of drawdown+ in_drawdown = True+ drawdown_start = i+ elif dd == 0 and in_drawdown:+ # End of drawdown (recovery)+ recovery_period = i - drawdown_start+ recovery_periods.append(recovery_period)+ in_drawdown = False++ if not recovery_periods:+ return {"no_complete_recoveries": True}++ avg_recovery_period = sum(recovery_periods) / len(recovery_periods)+ max_recovery_period = max(recovery_periods)++ return {+ 'average_recovery_period': avg_recovery_period,+ 'maximum_recovery_period': max_recovery_period,+ 'number_of_recoveries': len(recovery_periods)+ }++ def _calculate_ulcer_index(self, drawdowns: List[Decimal]) -> Decimal:+ """Calculate Ulcer Index (alternative drawdown measure)"""+ if not drawdowns:+ return Decimal('0')++ # Ulcer Index = sqrt(sum(drawdown^2) / n)+ squared_drawdowns = [dd ** 2 for dd in drawdowns]+ mean_squared_dd = sum(squared_drawdowns) / len(squared_drawdowns)++ return mean_squared_dd.sqrt()++ def _calculate_factor_exposures(self, portfolio_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]]) -> Dict[str, float]:+ """Calculate factor exposures using regression"""+ try:+ # Prepare data for regression+ y = [float(r) for r in portfolio_returns]++ # Create factor matrix+ factors = []+ factor_names = []++ for factor_name, returns in factor_returns.items():+ if len(returns) == len(portfolio_returns):+ factors.append([float(r) for r in returns])+ factor_names.append(factor_name)++ if not factors:+ return {}++ # Use simple matrix operations instead of numpy if not available+ try:+ import numpy as np+ X = np.array(factors).T+ X = np.column_stack([np.ones(len(y)), X])++ # Perform regression+ coefficients = np.linalg.lstsq(X, y, rcond=None)[0]++ # Format results+ exposures = {'alpha': float(coefficients[0])}+ for i, factor_name in enumerate(factor_names):+ exposures[f'{factor_name}_beta'] = float(coefficients[i + 1])++ # Calculate R-squared+ y_pred = X @ coefficients+ ss_res = np.sum((np.array(y) - y_pred) ** 2)+ ss_tot = np.sum((np.array(y) - np.mean(y)) ** 2)+ r_squared = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0+ exposures['r_squared'] = float(r_squared)++ return exposures++ except ImportError:+ # Fallback to simple correlation-based approach+ exposures = {}++ for factor_name, factor_rets in zip(factor_names, factors):+ if len(factor_rets) == len(portfolio_returns):+ # Simple correlation as proxy for beta+ correlation = self._calculate_correlation(portfolio_returns,+ [Decimal(str(r)) for r in factor_rets])+ exposures[f'{factor_name}_beta'] = float(correlation)++ return exposures++ except Exception as e:+ logger.error(f"Error calculating factor exposures: {str(e)}")+ return {}++ def _calculate_risk_contributions(self, portfolio_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]],+ factor_exposures: Dict[str, float]) -> Dict[str, float]:+ """Calculate risk contribution by factor"""+ risk_contributions = {}++ portfolio_variance = float(self._calculate_volatility(portfolio_returns) ** 2)++ for factor_name, factor_rets in factor_returns.items():+ beta_key = f'{factor_name}_beta'+ if beta_key in factor_exposures and len(factor_rets) == len(portfolio_returns):+ factor_beta = Decimal(str(factor_exposures[beta_key]))+ factor_variance = self._calculate_volatility([Decimal(str(r)) for r in factor_rets]) ** 2++ # Risk contribution = beta^2 * factor_variance / portfolio_variance+ if portfolio_variance > 0:+ risk_contrib = float((factor_beta ** 2) * factor_variance / Decimal(str(portfolio_variance)))+ risk_contributions[factor_name] = risk_contrib++ return risk_contributions++ def _calculate_idiosyncratic_risk(self, portfolio_returns: List[Decimal],+ factor_returns: Dict[str, List[Decimal]],+ factor_exposures: Dict[str, float]) -> Decimal:+ """Calculate idiosyncratic (specific) risk"""+ try:+ # Calculate explained variance by factors+ total_variance = self._calculate_volatility(portfolio_returns) ** 2++ explained_variance = Decimal('0')+ for factor_name, factor_rets in factor_returns.items():+ beta_key = f'{factor_name}_beta'+ if beta_key in factor_exposures and len(factor_rets) == len(portfolio_returns):+ factor_beta = Decimal(str(factor_exposures[beta_key]))+ factor_variance = self._calculate_volatility([Decimal(str(r)) for r in factor_rets]) ** 2+ explained_variance += (factor_beta ** 2) * factor_variance++ # Idiosyncratic risk = total risk - systematic risk+ idiosyncratic_variance = max(Decimal('0'), total_variance - explained_variance)+ return idiosyncratic_variance.sqrt()++ except Exception:+ return Decimal('0')++ def _calculate_scenario_impact(self, base_returns: List[Decimal],+ scenario_params: Dict[str, Decimal]) -> Dict[str, Any]:+ """Calculate impact of specific scenario"""+ scenario_impact = {}++ # Apply scenario shocks to base returns+ shock_magnitude = scenario_params.get('shock_magnitude', Decimal('0'))+ shock_probability = scenario_params.get('probability', Decimal('1'))++ # Calculate scenario return+ base_mean = sum(base_returns) / len(base_returns) if base_returns else Decimal('0')+ scenario_return = base_mean + shock_magnitude++ scenario_impact['scenario_return'] = float(scenario_return)+ scenario_impact['shock_magnitude'] = float(shock_magnitude)+ scenario_impact['probability'] = float(shock_probability)++ # Expected impact (probability-weighted)+ expected_impact = scenario_return * shock_probability+ scenario_impact['expected_impact'] = float(expected_impact)++ return scenario_impact++ def _summarize_scenario_outcomes(self, scenario_results: Dict[str, Any]) -> Dict[str, Any]:+ """Summarize scenario analysis outcomes"""+ summary = {}++ scenario_returns = []+ expected_impacts = []++ for scenario_name, scenario_data in scenario_results.items():+ if isinstance(scenario_data, dict) and 'scenario_return' in scenario_data:+ scenario_returns.append(scenario_data['scenario_return'])+ if 'expected_impact' in scenario_data:+ expected_impacts.append(scenario_data['expected_impact'])++ if scenario_returns:+ summary['best_case_return'] = max(scenario_returns)+ summary['worst_case_return'] = min(scenario_returns)+ summary['scenario_range'] = max(scenario_returns) - min(scenario_returns)++ if expected_impacts:+ summary['expected_scenario_impact'] = sum(expected_impacts) / len(expected_impacts)++ return summary++ def _find_worst_consecutive_periods(self, returns: List[Decimal], num_periods: int) -> Decimal:+ """Find worst consecutive period returns"""+ if len(returns) < num_periods:+ return Decimal('0')++ worst_cumulative = Decimal('0')++ for i in range(len(returns) - num_periods + 1):+ cumulative_return = Decimal('1')+ for j in range(i, i + num_periods):+ cumulative_return *= (Decimal('1') + returns[j])++ period_return = cumulative_return - Decimal('1')+ if period_return < worst_cumulative:+ worst_cumulative = period_return++ return worst_cumulative++ def _get_asset_class_scenarios(self, asset_class: AssetClass) -> Dict[str, Any]:+ """Get asset class specific stress scenarios"""+ scenarios = {}++ if asset_class == AssetClass.PRIVATE_EQUITY:+ scenarios.update({+ 'recession_scenario': {+ 'description': 'Economic recession impact',+ 'expected_impact': -0.30, # -30%+ 'recovery_time': '24_months'+ },+ 'credit_crunch': {+ 'description': 'Limited exit opportunities',+ 'expected_impact': -0.25,+ 'recovery_time': '18_months'+ }+ })++ elif asset_class == AssetClass.REAL_ESTATE:+ scenarios.update({+ 'interest_rate_shock': {+ 'description': '300bp rate increase',+ 'expected_impact': -0.20,+ 'recovery_time': '12_months'+ },+ 'property_market_crash': {+ 'description': 'Property values decline',+ 'expected_impact': -0.35,+ 'recovery_time': '36_months'+ }+ })++ elif asset_class == AssetClass.COMMODITIES:+ scenarios.update({+ 'demand_shock': {+ 'description': 'Global demand reduction',+ 'expected_impact': -0.40,+ 'recovery_time': '6_months'+ },+ 'supply_disruption': {+ 'description': 'Supply chain disruption',+ 'expected_impact': 0.25, # Positive for commodity prices+ 'recovery_time': '12_months'+ }+ })++ elif asset_class == AssetClass.HEDGE_FUND:+ scenarios.update({+ 'market_volatility_spike': {+ 'description': 'VIX above 40',+ 'expected_impact': -0.15,+ 'recovery_time': '3_months'+ },+ 'liquidity_crisis': {+ 'description': 'Redemption pressure',+ 'expected_impact': -0.20,+ 'recovery_time': '6_months'+ }+ })++ elif asset_class == AssetClass.DIGITAL_ASSETS:+ scenarios.update({+ 'regulatory_crackdown': {+ 'description': 'Major regulatory restrictions',+ 'expected_impact': -0.50,+ 'recovery_time': '12_months'+ },+ 'crypto_winter': {+ 'description': 'Extended bear market',+ 'expected_impact': -0.70,+ 'recovery_time': '24_months'+ }+ })++ return scenarios+++class PortfolioRiskAnalyzer:+ """+ Portfolio-level risk analysis across multiple alternative investments+ CFA Standards: Portfolio risk management and optimization+ """++ def __init__(self):+ self.risk_analyzer = RiskAnalyzer()++ def portfolio_var_analysis(self, asset_returns: Dict[str, List[Decimal]],+ portfolio_weights: Dict[str, Decimal]) -> Dict[str, Any]:+ """+ Calculate portfolio VaR considering correlations+ CFA Standard: Portfolio VaR with correlation matrix+ """+ if not asset_returns or not portfolio_weights:+ return {"error": "Asset returns and weights required"}++ # Validate weights sum to 1+ total_weight = sum(portfolio_weights.values())+ if abs(total_weight - Decimal('1')) > Decimal('0.01'):+ return {"error": f"Weights sum to {total_weight}, should be 1.0"}++ # Calculate portfolio returns+ portfolio_returns = self._calculate_portfolio_returns(asset_returns, portfolio_weights)++ if not portfolio_returns:+ return {"error": "Cannot calculate portfolio returns"}++ # Portfolio VaR analysis+ portfolio_var = self.risk_analyzer.value_at_risk_analysis(portfolio_returns)++ # Component VaR (individual asset contributions)+ component_var = self._calculate_component_var(asset_returns, portfolio_weights)++ return {+ "portfolio_var": portfolio_var,+ "component_var": component_var,+ "portfolio_statistics": {+ "mean_return": float(sum(portfolio_returns) / len(portfolio_returns)),+ "volatility": float(self.risk_analyzer._calculate_volatility(portfolio_returns)),+ "number_of_assets": len(portfolio_weights)+ }+ }++ def risk_budget_analysis(self, asset_returns: Dict[str, List[Decimal]],+ target_risk_budgets: Dict[str, Decimal]) -> Dict[str, Any]:+ """+ Analyze risk budgeting and contribution+ CFA Standard: Risk budgeting framework+ """+ risk_analysis = {}++ # Calculate individual asset volatilities+ asset_volatilities = {}+ for asset, returns in asset_returns.items():+ vol = self.risk_analyzer._calculate_volatility(returns)+ asset_volatilities[asset] = vol++ # Calculate correlation matrix+ correlation_matrix = self.risk_analyzer._calculate_correlation_matrix(asset_returns)++ # Risk contribution analysis+ risk_contributions = self._calculate_risk_contributions_detailed(+ asset_volatilities, correlation_matrix, target_risk_budgets+ )++ risk_analysis["risk_contributions"] = risk_contributions+ risk_analysis["target_risk_budgets"] = {k: float(v) for k, v in target_risk_budgets.items()}+ risk_analysis["asset_volatilities"] = {k: float(v) for k, v in asset_volatilities.items()}++ return risk_analysis++ def portfolio_stress_testing(self, asset_returns: Dict[str, List[Decimal]],+ portfolio_weights: Dict[str, Decimal],+ stress_scenarios: Dict[str, Dict[str, Decimal]]) -> Dict[str, Any]:+ """+ Comprehensive portfolio stress testing+ CFA Standard: Portfolio stress testing across scenarios+ """+ stress_results = {}++ # Calculate baseline portfolio performance+ portfolio_returns = self._calculate_portfolio_returns(asset_returns, portfolio_weights)+ baseline_metrics = {+ "mean_return": float(sum(portfolio_returns) / len(portfolio_returns)),+ "volatility": float(self.risk_analyzer._calculate_volatility(portfolio_returns))+ }+ stress_results["baseline_metrics"] = baseline_metrics++ # Apply stress scenarios+ scenario_impacts = {}+ for scenario_name, scenario_shocks in stress_scenarios.items():+ scenario_impact = self._apply_portfolio_stress_scenario(+ asset_returns, portfolio_weights, scenario_shocks+ )+ scenario_impacts[scenario_name] = scenario_impact++ stress_results["scenario_impacts"] = scenario_impacts++ # Worst case analysis+ worst_case = self._identify_worst_case_scenario(scenario_impacts)+ stress_results["worst_case_scenario"] = worst_case++ return stress_results++ def liquidity_risk_portfolio(self, asset_liquidity_scores: Dict[str, float],+ portfolio_weights: Dict[str, Decimal]) -> Dict[str, Any]:+ """+ Analyze portfolio-level liquidity risk+ CFA Standard: Portfolio liquidity management+ """+ liquidity_analysis = {}++ # Weighted average liquidity score+ weighted_liquidity = Decimal('0')+ for asset, weight in portfolio_weights.items():+ if asset in asset_liquidity_scores:+ liquidity_score = Decimal(str(asset_liquidity_scores[asset]))+ weighted_liquidity += weight * liquidity_score++ liquidity_analysis["weighted_average_liquidity"] = float(weighted_liquidity)++ # Liquidity concentration+ liquidity_buckets = {"high": Decimal('0'), "medium": Decimal('0'), "low": Decimal('0')}++ for asset, weight in portfolio_weights.items():+ if asset in asset_liquidity_scores:+ score = asset_liquidity_scores[asset]+ if score >= 70:+ liquidity_buckets["high"] += weight+ elif score >= 40:+ liquidity_buckets["medium"] += weight+ else:+ liquidity_buckets["low"] += weight++ liquidity_analysis["liquidity_buckets"] = {k: float(v) for k, v in liquidity_buckets.items()}++ # Liquidity risk assessment+ if weighted_liquidity >= 70:+ risk_level = "Low"+ elif weighted_liquidity >= 50:+ risk_level = "Medium"+ else:+ risk_level = "High"++ liquidity_analysis["portfolio_liquidity_risk"] = risk_level++ return liquidity_analysis++ def concentration_risk_analysis(self, portfolio_weights: Dict[str, Decimal],+ asset_classifications: Dict[str, Dict[str, str]]) -> Dict[str, Any]:+ """+ Analyze concentration risk across multiple dimensions+ CFA Standard: Concentration risk management+ """+ concentration_analysis = {}++ # Single asset concentration+ max_weight = max(portfolio_weights.values())+ concentration_analysis["maximum_single_asset_weight"] = float(max_weight)++ # Asset class concentration+ asset_class_weights = {}+ for asset, weight in portfolio_weights.items():+ if asset in asset_classifications:+ asset_class = asset_classifications[asset].get('asset_class', 'unknown')+ if asset_class not in asset_class_weights:+ asset_class_weights[asset_class] = Decimal('0')+ asset_class_weights[asset_class] += weight++ concentration_analysis["asset_class_concentration"] = {k: float(v) for k, v in asset_class_weights.items()}++ # Geographic concentration (if available)+ geographic_weights = {}+ for asset, weight in portfolio_weights.items():+ if asset in asset_classifications:+ geography = asset_classifications[asset].get('geography', 'unknown')+ if geography not in geographic_weights:+ geographic_weights[geography] = Decimal('0')+ geographic_weights[geography] += weight++ concentration_analysis["geographic_concentration"] = {k: float(v) for k, v in geographic_weights.items()}++ # Concentration risk score+ concentration_score = self._calculate_concentration_score(+ max_weight, asset_class_weights, geographic_weights+ )+ concentration_analysis["concentration_risk_score"] = concentration_score++ return concentration_analysis++ # Helper methods for portfolio risk analysis++ def _calculate_portfolio_returns(self, asset_returns: Dict[str, List[Decimal]],+ portfolio_weights: Dict[str, Decimal]) -> List[Decimal]:+ """Calculate portfolio returns given weights"""+ # Find minimum length across all return series+ min_length = min(len(returns) for returns in asset_returns.values() if returns)++ if min_length == 0:+ return []++ portfolio_returns = []++ for i in range(min_length):+ period_return = Decimal('0')+ for asset, weight in portfolio_weights.items():+ if asset in asset_returns and i < len(asset_returns[asset]):+ period_return += weight * asset_returns[asset][i]+ portfolio_returns.append(period_return)++ return portfolio_returns++ def _calculate_component_var(self, asset_returns: Dict[str, List[Decimal]],+ portfolio_weights: Dict[str, Decimal]) -> Dict[str, Any]:+ """Calculate component VaR for each asset"""+ component_vars = {}++ # Calculate portfolio returns+ portfolio_returns = self._calculate_portfolio_returns(asset_returns, portfolio_weights)++ if not portfolio_returns:+ return component_vars++ # Portfolio VaR+ portfolio_var_95 = self.risk_analyzer.math.var_historical(portfolio_returns, Decimal('0.05'))++ # Component VaR (simplified calculation)+ for asset, weight in portfolio_weights.items():+ if asset in asset_returns:+ asset_return_series = asset_returns[asset][:len(portfolio_returns)]++ # Calculate correlation with portfolio+ if asset_return_series:+ correlation = self.risk_analyzer._calculate_correlation(+ asset_return_series, portfolio_returns+ )++ asset_vol = self.risk_analyzer._calculate_volatility(asset_return_series)+ portfolio_vol = self.risk_analyzer._calculate_volatility(portfolio_returns)++ # Component VaR = weight * correlation * (asset_vol / portfolio_vol) * portfolio_var+ if portfolio_vol > 0:+ component_var = weight * correlation * (asset_vol / portfolio_vol) * portfolio_var_95+ component_vars[asset] = float(component_var)++ return component_vars++ def _calculate_risk_contributions_detailed(self, asset_volatilities: Dict[str, Decimal],+ correlation_matrix: Dict[str, Dict[str, float]],+ target_risk_budgets: Dict[str, Decimal]) -> Dict[str, Any]:+ """Calculate detailed risk contributions"""+ risk_contributions = {}++ assets = list(asset_volatilities.keys())++ # Calculate marginal risk contributions (simplified)+ for asset in assets:+ asset_vol = asset_volatilities[asset]++ # Average correlation with other assets+ correlations = []+ for other_asset in assets:+ if other_asset != asset and other_asset in correlation_matrix.get(asset, {}):+ correlations.append(correlation_matrix[asset][other_asset])++ avg_correlation = sum(correlations) / len(correlations) if correlations else 0++ # Risk contribution approximation+ target_budget = target_risk_budgets.get(asset, Decimal('0'))+ risk_contribution = float(asset_vol * target_budget * Decimal(str(avg_correlation)))++ risk_contributions[asset] = {+ "risk_contribution": risk_contribution,+ "target_budget": float(target_budget),+ "asset_volatility": float(asset_vol),+ "average_correlation": avg_correlation+ }++ return risk_contributions++ def _apply_portfolio_stress_scenario(self, asset_returns: Dict[str, List[Decimal]],+ portfolio_weights: Dict[str, Decimal],+ scenario_shocks: Dict[str, Decimal]) -> Dict[str, Any]:+ """Apply stress scenario to portfolio"""+ scenario_impact = {}++ # Calculate baseline portfolio return+ portfolio_returns = self._calculate_portfolio_returns(asset_returns, portfolio_weights)+ baseline_return = sum(portfolio_returns) / len(portfolio_returns) if portfolio_returns else Decimal('0')++ # Apply shocks to each asset+ stressed_return = Decimal('0')+ for asset, weight in portfolio_weights.items():+ asset_shock = scenario_shocks.get(asset, Decimal('0'))++ if asset in asset_returns and asset_returns[asset]:+ asset_baseline = sum(asset_returns[asset]) / len(asset_returns[asset])+ stressed_asset_return = asset_baseline + asset_shock+ else:+ stressed_asset_return = asset_shock++ stressed_return += weight * stressed_asset_return++ # Calculate impact+ impact = stressed_return - baseline_return++ scenario_impact["baseline_return"] = float(baseline_return)+ scenario_impact["stressed_return"] = float(stressed_return)+ scenario_impact["impact"] = float(impact)+ scenario_impact["impact_percentage"] = float(impact / baseline_return * 100) if baseline_return != 0 else 0++ return scenario_impact++ def _identify_worst_case_scenario(self, scenario_impacts: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:+ """Identify worst case scenario from stress testing"""+ worst_case = {}+ worst_impact = 0+ worst_scenario = None++ for scenario_name, impact_data in scenario_impacts.items():+ if isinstance(impact_data, dict) and 'impact' in impact_data:+ impact = impact_data['impact']+ if impact < worst_impact:+ worst_impact = impact+ worst_scenario = scenario_name++ if worst_scenario:+ worst_case["worst_scenario_name"] = worst_scenario+ worst_case["worst_impact"] = worst_impact+ worst_case["worst_scenario_details"] = scenario_impacts[worst_scenario]++ return worst_case++ def _calculate_concentration_score(self, max_single_weight: Decimal,+ asset_class_weights: Dict[str, Decimal],+ geographic_weights: Dict[str, Decimal]) -> Dict[str, Any]:+ """Calculate concentration risk score"""+ score_components = {}++ # Single asset concentration score (0-100, lower is better)+ single_asset_score = float(max_single_weight * 100)+ score_components["single_asset_concentration"] = single_asset_score++ # Asset class concentration (Herfindahl index)+ if asset_class_weights:+ hhi_asset_class = sum(weight ** 2 for weight in asset_class_weights.values())+ asset_class_score = float(hhi_asset_class * 100)+ score_components["asset_class_concentration"] = asset_class_score++ # Geographic concentration+ if geographic_weights:+ hhi_geographic = sum(weight ** 2 for weight in geographic_weights.values())+ geographic_score = float(hhi_geographic * 100)+ score_components["geographic_concentration"] = geographic_score++ # Composite concentration score+ scores = list(score_components.values())+ composite_score = sum(scores) / len(scores) if scores else 0++ # Risk level+ if composite_score < 30:+ risk_level = "Low"+ elif composite_score < 60:+ risk_level = "Medium"+ else:+ risk_level = "High"++ return {+ "composite_concentration_score": composite_score,+ "concentration_risk_level": risk_level,+ "score_components": score_components+ }+++# Export main components+__all__ = ['RiskAnalyzer', 'PortfolioRiskAnalyzer']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/analytics.pynew file mode 100644index 000000000..da8160146--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/analytics.py@@ -0,0 +1,710 @@+"""+Derivatives Portfolio Analytics Module+===================================++Advanced portfolio analytics and risk metrics framework for derivative portfolios including options, forwards, futures, and swaps. Provides comprehensive risk measurement, scenario analysis, stress testing, and performance attribution capabilities.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Derivative portfolio positions and holdings+ - Market data for underlying assets (spot prices, volatilities, interest rates)+ - Historical price series for risk calculations+ - Option pricing models and parameters+ - Counterparty and market risk factors+ - Benchmark return series for performance comparison++OUTPUT:+ - Portfolio risk metrics (VaR, CVaR, maximum drawdown, volatility)+ - Scenario analysis and stress testing results+ - Sensitivity analysis and Greeks aggregation+ - Performance attribution and P&L decomposition+ - Monte Carlo simulation outcomes+ - Portfolio optimization recommendations++PARAMETERS:+ - confidence_levels: VaR confidence levels - default: [0.95, 0.99]+ - num_simulations: Number of Monte Carlo simulations - default: 10000+ - time_horizon: Analysis time horizon in days - default: 30+ - risk_free_rate: Risk-free rate for calculations - default: 0.02+ - objective: Portfolio optimization objective - default: "sharpe_ratio"+ - constraints: Portfolio optimization constraints+"""++import numpy as np+import pandas as pd+from typing import Dict, List, Tuple, Optional, Union, Any+from datetime import datetime, timedelta+from dataclasses import dataclass, field+from enum import Enum+import logging+from scipy import stats+from scipy.optimize import minimize++from .core import (+ DerivativeInstrument, MarketData, PricingResult,+ ValidationError, ModelValidator, Constants+)+from .options import VanillaOption, OptionGreeks, BlackScholesPricingEngine+from .forward_commitments import ForwardCommitmentPricingEngine++logger = logging.getLogger(__name__)+++class RiskMeasure(Enum):+ """Types of risk measures"""+ VALUE_AT_RISK = "var"+ CONDITIONAL_VAR = "cvar"+ EXPECTED_SHORTFALL = "expected_shortfall"+ MAXIMUM_DRAWDOWN = "max_drawdown"+ VOLATILITY = "volatility"+ BETA = "beta"+ SHARPE_RATIO = "sharpe_ratio"+++class ScenarioType(Enum):+ """Types of scenario analysis"""+ STRESS_TEST = "stress_test"+ MONTE_CARLO = "monte_carlo"+ HISTORICAL_SIMULATION = "historical_simulation"+ SENSITIVITY_ANALYSIS = "sensitivity_analysis"+++@dataclass+class PortfolioPosition:+ """Individual position in derivatives portfolio"""+ instrument: DerivativeInstrument+ quantity: float+ entry_price: float+ entry_date: datetime+ current_value: float = 0.0+ unrealized_pnl: float = 0.0++ def __post_init__(self):+ if self.quantity == 0:+ raise ValidationError("Position quantity cannot be zero")+++@dataclass+class RiskMetrics:+ """Container for portfolio risk metrics"""+ portfolio_value: float+ var_95: float = 0.0+ var_99: float = 0.0+ cvar_95: float = 0.0+ cvar_99: float = 0.0+ volatility: float = 0.0+ maximum_drawdown: float = 0.0+ sharpe_ratio: float = 0.0+ sortino_ratio: float = 0.0+ calmar_ratio: float = 0.0+ beta: float = 0.0++ # Greeks aggregation+ total_delta: float = 0.0+ total_gamma: float = 0.0+ total_theta: float = 0.0+ total_vega: float = 0.0+ total_rho: float = 0.0+++@dataclass+class ScenarioResult:+ """Results from scenario analysis"""+ scenario_name: str+ scenario_type: ScenarioType+ base_portfolio_value: float+ scenario_portfolio_value: float+ pnl_change: float+ percentage_change: float+ probability: Optional[float] = None+ scenario_parameters: Dict[str, Any] = field(default_factory=dict)+++@dataclass+class SensitivityResult:+ """Results from sensitivity analysis"""+ parameter_name: str+ base_value: float+ shock_size: float+ portfolio_value_change: float+ sensitivity: float # Change per unit of parameter+ elasticity: float # Percentage change per percentage change in parameter+++class DerivativesPortfolio:+ """Derivatives portfolio management and analytics"""++ def __init__(self, portfolio_id: str = None):+ self.portfolio_id = portfolio_id or f"portfolio_{datetime.now().strftime('%Y%m%d_%H%M%S')}"+ self.positions: List[PortfolioPosition] = []+ self.creation_date = datetime.now()+ self.last_update = None++ # Pricing engines+ self.options_engine = BlackScholesPricingEngine()+ self.forwards_engine = ForwardCommitmentPricingEngine()++ def add_position(self, instrument: DerivativeInstrument, quantity: float,+ entry_price: float, entry_date: datetime = None):+ """Add position to portfolio"""+ if entry_date is None:+ entry_date = datetime.now()++ position = PortfolioPosition(+ instrument=instrument,+ quantity=quantity,+ entry_price=entry_price,+ entry_date=entry_date+ )++ self.positions.append(position)+ self.last_update = datetime.now()+ logger.info(f"Added position: {quantity} units of {instrument}")++ def remove_position(self, position_index: int):+ """Remove position from portfolio"""+ if 0 <= position_index < len(self.positions):+ removed_position = self.positions.pop(position_index)+ self.last_update = datetime.now()+ logger.info(f"Removed position: {removed_position.instrument}")+ else:+ raise ValueError("Invalid position index")++ def update_positions(self, market_data: MarketData) -> float:+ """Update all position values and calculate portfolio value"""+ total_value = 0.0++ for position in self.positions:+ try:+ # Price the instrument+ if hasattr(position.instrument, 'option_type'): # Options+ pricing_result = self.options_engine.price(position.instrument, market_data)+ else: # Forward commitments+ pricing_result = self.forwards_engine.price(position.instrument, market_data)++ # Update position values+ position.current_value = pricing_result.fair_value * position.quantity+ position.unrealized_pnl = position.current_value - (position.entry_price * position.quantity)++ total_value += position.current_value++ except Exception as e:+ logger.error(f"Error pricing position {position.instrument}: {e}")+ # Use entry price as fallback+ position.current_value = position.entry_price * position.quantity+ total_value += position.current_value++ self.last_update = datetime.now()+ return total_value++ def get_portfolio_greeks(self, market_data: MarketData) -> Dict[str, float]:+ """Calculate aggregated portfolio Greeks"""+ total_greeks = {+ 'delta': 0.0, 'gamma': 0.0, 'theta': 0.0,+ 'vega': 0.0, 'rho': 0.0+ }++ for position in self.positions:+ if hasattr(position.instrument, 'option_type'): # Options only+ try:+ greeks = self.options_engine.calculate_greeks(position.instrument, market_data)++ total_greeks['delta'] += greeks.delta * position.quantity+ total_greeks['gamma'] += greeks.gamma * position.quantity+ total_greeks['theta'] += greeks.theta * position.quantity+ total_greeks['vega'] += greeks.vega * position.quantity+ total_greeks['rho'] += greeks.rho * position.quantity++ except Exception as e:+ logger.warning(f"Could not calculate Greeks for {position.instrument}: {e}")++ return total_greeks++ def get_portfolio_summary(self, market_data: MarketData) -> Dict[str, Any]:+ """Get comprehensive portfolio summary"""+ portfolio_value = self.update_positions(market_data)+ greeks = self.get_portfolio_greeks(market_data)++ total_pnl = sum(pos.unrealized_pnl for pos in self.positions)++ return {+ 'portfolio_id': self.portfolio_id,+ 'portfolio_value': portfolio_value,+ 'total_unrealized_pnl': total_pnl,+ 'number_of_positions': len(self.positions),+ 'last_update': self.last_update,+ 'greeks': greeks,+ 'positions_summary': [+ {+ 'instrument_type': pos.instrument.derivative_type.value,+ 'quantity': pos.quantity,+ 'current_value': pos.current_value,+ 'unrealized_pnl': pos.unrealized_pnl,+ 'entry_date': pos.entry_date+ }+ for pos in self.positions+ ]+ }+++class RiskAnalyzer:+ """Advanced risk analysis for derivatives portfolios"""++ def __init__(self, confidence_levels: List[float] = None):+ self.confidence_levels = confidence_levels or [0.95, 0.99]+ self.simulation_results = []++ def calculate_var(self, returns: np.ndarray, confidence_level: float = 0.95) -> float:+ """Calculate Value at Risk"""+ if len(returns) == 0:+ return 0.0++ return np.percentile(returns, (1 - confidence_level) * 100)++ def calculate_cvar(self, returns: np.ndarray, confidence_level: float = 0.95) -> float:+ """Calculate Conditional Value at Risk (Expected Shortfall)"""+ if len(returns) == 0:+ return 0.0++ var_threshold = self.calculate_var(returns, confidence_level)+ tail_losses = returns[returns <= var_threshold]++ return np.mean(tail_losses) if len(tail_losses) > 0 else var_threshold++ def calculate_maximum_drawdown(self, portfolio_values: np.ndarray) -> float:+ """Calculate maximum drawdown"""+ if len(portfolio_values) < 2:+ return 0.0++ # Calculate running maximum+ running_max = np.maximum.accumulate(portfolio_values)++ # Calculate drawdowns+ drawdowns = (portfolio_values - running_max) / running_max++ return np.min(drawdowns)++ def calculate_portfolio_risk_metrics(self, portfolio: DerivativesPortfolio,+ historical_returns: np.ndarray = None,+ benchmark_returns: np.ndarray = None,+ risk_free_rate: float = 0.02) -> RiskMetrics:+ """Calculate comprehensive risk metrics"""++ if historical_returns is None:+ # Generate sample returns for demonstration+ historical_returns = np.random.normal(0.001, 0.02, 252) # Daily returns for 1 year++ portfolio_value = sum(pos.current_value for pos in portfolio.positions)++ # Basic risk metrics+ volatility = np.std(historical_returns) * np.sqrt(252) # Annualized+ var_95 = self.calculate_var(historical_returns, 0.95)+ var_99 = self.calculate_var(historical_returns, 0.99)+ cvar_95 = self.calculate_cvar(historical_returns, 0.95)+ cvar_99 = self.calculate_cvar(historical_returns, 0.99)++ # Calculate portfolio values for drawdown+ portfolio_values = portfolio_value * (1 + np.cumsum(historical_returns))+ max_drawdown = self.calculate_maximum_drawdown(portfolio_values)++ # Performance ratios+ excess_returns = historical_returns - risk_free_rate / 252+ sharpe_ratio = np.mean(excess_returns) / np.std(historical_returns) * np.sqrt(252) if np.std(+ historical_returns) > 0 else 0++ # Sortino ratio (using downside deviation)+ downside_returns = historical_returns[historical_returns < 0]+ downside_deviation = np.std(downside_returns) if len(downside_returns) > 0 else np.std(historical_returns)+ sortino_ratio = np.mean(excess_returns) / downside_deviation * np.sqrt(252) if downside_deviation > 0 else 0++ # Calmar ratio+ calmar_ratio = np.mean(excess_returns) * 252 / abs(max_drawdown) if max_drawdown != 0 else 0++ # Beta calculation+ beta = 0.0+ if benchmark_returns is not None and len(benchmark_returns) == len(historical_returns):+ covariance = np.cov(historical_returns, benchmark_returns)[0, 1]+ benchmark_variance = np.var(benchmark_returns)+ beta = covariance / benchmark_variance if benchmark_variance > 0 else 0++ return RiskMetrics(+ portfolio_value=portfolio_value,+ var_95=var_95 * portfolio_value,+ var_99=var_99 * portfolio_value,+ cvar_95=cvar_95 * portfolio_value,+ cvar_99=cvar_99 * portfolio_value,+ volatility=volatility,+ maximum_drawdown=max_drawdown,+ sharpe_ratio=sharpe_ratio,+ sortino_ratio=sortino_ratio,+ calmar_ratio=calmar_ratio,+ beta=beta+ )+++class ScenarioAnalyzer:+ """Scenario analysis and stress testing"""++ def __init__(self):+ self.scenarios = {}++ def add_scenario(self, name: str, market_shocks: Dict[str, float]):+ """Add predefined scenario"""+ self.scenarios[name] = market_shocks++ def stress_test(self, portfolio: DerivativesPortfolio,+ base_market_data: MarketData,+ stress_scenarios: Dict[str, Dict[str, float]] = None) -> List[ScenarioResult]:+ """Perform stress testing on portfolio"""++ if stress_scenarios is None:+ stress_scenarios = self._get_default_stress_scenarios()++ # Calculate base portfolio value+ base_value = portfolio.update_positions(base_market_data)++ results = []++ for scenario_name, shocks in stress_scenarios.items():+ try:+ # Apply shocks to market data+ stressed_market_data = self._apply_market_shocks(base_market_data, shocks)++ # Calculate portfolio value under stress+ stressed_value = portfolio.update_positions(stressed_market_data)++ pnl_change = stressed_value - base_value+ percentage_change = (pnl_change / base_value * 100) if base_value != 0 else 0++ result = ScenarioResult(+ scenario_name=scenario_name,+ scenario_type=ScenarioType.STRESS_TEST,+ base_portfolio_value=base_value,+ scenario_portfolio_value=stressed_value,+ pnl_change=pnl_change,+ percentage_change=percentage_change,+ scenario_parameters=shocks+ )++ results.append(result)++ except Exception as e:+ logger.error(f"Error in stress test scenario {scenario_name}: {e}")++ return results++ def monte_carlo_simulation(self, portfolio: DerivativesPortfolio,+ base_market_data: MarketData,+ num_simulations: int = 10000,+ time_horizon: int = 30) -> List[ScenarioResult]:+ """Monte Carlo simulation for portfolio"""++ base_value = portfolio.update_positions(base_market_data)+ results = []++ # Simulation parameters+ dt = 1 / 252 # Daily time step+ drift = 0.0001 # Small positive drift+ volatility = 0.02 # 2% daily volatility++ for i in range(num_simulations):+ try:+ # Generate random price path+ random_shocks = np.random.normal(0, 1, time_horizon)++ # Simulate final market conditions+ final_spot_multiplier = np.exp(np.sum(+ (drift - 0.5 * volatility ** 2) * dt + volatility * np.sqrt(dt) * random_shocks+ ))++ simulated_market_data = MarketData(+ spot_price=base_market_data.spot_price * final_spot_multiplier,+ risk_free_rate=base_market_data.risk_free_rate,+ dividend_yield=base_market_data.dividend_yield,+ volatility=base_market_data.volatility,+ time_to_expiry=max(0, base_market_data.time_to_expiry - time_horizon / 252)+ )++ simulated_value = portfolio.update_positions(simulated_market_data)+ pnl_change = simulated_value - base_value+ percentage_change = (pnl_change / base_value * 100) if base_value != 0 else 0++ result = ScenarioResult(+ scenario_name=f"MC_Simulation_{i + 1}",+ scenario_type=ScenarioType.MONTE_CARLO,+ base_portfolio_value=base_value,+ scenario_portfolio_value=simulated_value,+ pnl_change=pnl_change,+ percentage_change=percentage_change,+ probability=1 / num_simulations,+ scenario_parameters={+ "final_spot_multiplier": final_spot_multiplier,+ "time_horizon_days": time_horizon+ }+ )++ results.append(result)++ except Exception as e:+ logger.warning(f"Error in MC simulation {i + 1}: {e}")++ return results++ def sensitivity_analysis(self, portfolio: DerivativesPortfolio,+ base_market_data: MarketData,+ parameters: List[str] = None,+ shock_sizes: Dict[str, float] = None) -> List[SensitivityResult]:+ """Perform sensitivity analysis on key parameters"""++ if parameters is None:+ parameters = ['spot_price', 'volatility', 'risk_free_rate', 'time_to_expiry']++ if shock_sizes is None:+ shock_sizes = {+ 'spot_price': 0.01, # 1%+ 'volatility': 0.01, # 1 percentage point+ 'risk_free_rate': 0.0025, # 25 basis points+ 'time_to_expiry': -1 / 365 # 1 day+ }++ base_value = portfolio.update_positions(base_market_data)+ results = []++ for param in parameters:+ if param not in shock_sizes:+ continue++ try:+ # Create shocked market data+ shocked_data = self._shock_parameter(base_market_data, param, shock_sizes[param])++ # Calculate portfolio value with shock+ shocked_value = portfolio.update_positions(shocked_data)++ # Calculate sensitivity metrics+ pnl_change = shocked_value - base_value+ base_param_value = getattr(base_market_data, param)++ # Linear sensitivity (change per unit)+ sensitivity = pnl_change / shock_sizes[param] if shock_sizes[param] != 0 else 0++ # Elasticity (percentage change per percentage change)+ if base_param_value != 0 and base_value != 0:+ elasticity = (pnl_change / base_value) / (shock_sizes[param] / base_param_value)+ else:+ elasticity = 0++ result = SensitivityResult(+ parameter_name=param,+ base_value=base_param_value,+ shock_size=shock_sizes[param],+ portfolio_value_change=pnl_change,+ sensitivity=sensitivity,+ elasticity=elasticity+ )++ results.append(result)++ except Exception as e:+ logger.error(f"Error in sensitivity analysis for {param}: {e}")++ return results++ def _get_default_stress_scenarios(self) -> Dict[str, Dict[str, float]]:+ """Get default stress test scenarios"""+ return {+ "Market_Crash": {+ "spot_price": -0.20, # 20% stock drop+ "volatility": 0.15, # Vol spike to 15%+ "risk_free_rate": -0.01 # Rate cut+ },+ "Vol_Spike": {+ "volatility": 0.20, # Extreme volatility+ "spot_price": -0.05 # 5% stock drop+ },+ "Interest_Rate_Shock": {+ "risk_free_rate": 0.02, # 200 bps rate increase+ "spot_price": -0.10 # 10% stock drop+ },+ "Time_Decay": {+ "time_to_expiry": -0.1, # 10% time decay+ "volatility": -0.05 # Vol compression+ },+ "Bull_Market": {+ "spot_price": 0.15, # 15% stock rally+ "volatility": -0.05 # Vol compression+ }+ }++ def _apply_market_shocks(self, base_data: MarketData, shocks: Dict[str, float]) -> MarketData:+ """Apply market shocks to create stressed market data"""+ return MarketData(+ spot_price=base_data.spot_price * (1 + shocks.get('spot_price', 0)),+ risk_free_rate=base_data.risk_free_rate + shocks.get('risk_free_rate', 0),+ dividend_yield=base_data.dividend_yield + shocks.get('dividend_yield', 0),+ volatility=max(0.001, base_data.volatility + shocks.get('volatility', 0)),+ time_to_expiry=max(0, base_data.time_to_expiry + shocks.get('time_to_expiry', 0))+ )++ def _shock_parameter(self, base_data: MarketData, parameter: str, shock: float) -> MarketData:+ """Apply shock to specific parameter"""+ data_dict = {+ 'spot_price': base_data.spot_price,+ 'risk_free_rate': base_data.risk_free_rate,+ 'dividend_yield': base_data.dividend_yield,+ 'volatility': base_data.volatility,+ 'time_to_expiry': base_data.time_to_expiry+ }++ if parameter in data_dict:+ if parameter == 'spot_price':+ data_dict[parameter] *= (1 + shock) # Percentage shock+ else:+ data_dict[parameter] += shock # Absolute shock++ return MarketData(**data_dict)+++class PerformanceAttribution:+ """Performance attribution analysis"""++ def __init__(self):+ self.attribution_factors = ['delta', 'gamma', 'theta', 'vega', 'rho']++ def attribute_pnl(self, portfolio: DerivativesPortfolio,+ initial_market_data: MarketData,+ final_market_data: MarketData) -> Dict[str, float]:+ """Attribute P&L to different risk factors"""++ # Calculate initial portfolio value and Greeks+ initial_value = portfolio.update_positions(initial_market_data)+ initial_greeks = portfolio.get_portfolio_greeks(initial_market_data)++ # Calculate final portfolio value+ final_value = portfolio.update_positions(final_market_data)+ total_pnl = final_value - initial_value++ # Calculate market moves+ spot_move = final_market_data.spot_price - initial_market_data.spot_price+ vol_move = final_market_data.volatility - initial_market_data.volatility+ rate_move = final_market_data.risk_free_rate - initial_market_data.risk_free_rate+ time_move = final_market_data.time_to_expiry - initial_market_data.time_to_expiry++ # Attribute P&L to Greeks+ delta_pnl = initial_greeks.get('delta', 0) * spot_move+ gamma_pnl = 0.5 * initial_greeks.get('gamma', 0) * (spot_move ** 2)+ theta_pnl = initial_greeks.get('theta', 0) * (-time_move * 365) # Convert to days+ vega_pnl = initial_greeks.get('vega', 0) * vol_move * 100 # Vega per 1% vol+ rho_pnl = initial_greeks.get('rho', 0) * rate_move * 100 # Rho per 1% rate++ # Calculate unexplained P&L+ explained_pnl = delta_pnl + gamma_pnl + theta_pnl + vega_pnl + rho_pnl+ unexplained_pnl = total_pnl - explained_pnl++ return {+ 'total_pnl': total_pnl,+ 'delta_pnl': delta_pnl,+ 'gamma_pnl': gamma_pnl,+ 'theta_pnl': theta_pnl,+ 'vega_pnl': vega_pnl,+ 'rho_pnl': rho_pnl,+ 'explained_pnl': explained_pnl,+ 'unexplained_pnl': unexplained_pnl,+ 'explanation_ratio': abs(explained_pnl / total_pnl) if total_pnl != 0 else 0+ }+++class PortfolioOptimizer:+ """Portfolio optimization for derivatives"""++ def __init__(self, objective: str = "sharpe_ratio"):+ self.objective = objective # "sharpe_ratio", "min_variance", "max_return"++ def optimize_weights(self, expected_returns: np.ndarray,+ covariance_matrix: np.ndarray,+ constraints: Dict = None) -> Dict[str, Any]:+ """Optimize portfolio weights"""++ n_assets = len(expected_returns)++ # Default constraints+ if constraints is None:+ constraints = {+ 'max_weight': 0.4, # Max 40% in any single asset+ 'min_weight': -0.2, # Allow 20% short positions+ 'target_return': None+ }++ # Objective function+ def objective_function(weights):+ portfolio_return = np.dot(weights, expected_returns)+ portfolio_variance = np.dot(weights.T, np.dot(covariance_matrix, weights))+ portfolio_std = np.sqrt(portfolio_variance)++ if self.objective == "sharpe_ratio":+ return -portfolio_return / portfolio_std if portfolio_std > 0 else 0+ elif self.objective == "min_variance":+ return portfolio_variance+ elif self.objective == "max_return":+ return -portfolio_return+ else:+ return portfolio_variance++ # Constraints+ constraint_list = [+ {'type': 'eq', 'fun': lambda w: np.sum(w) - 1} # Weights sum to 1+ ]++ if constraints.get('target_return'):+ constraint_list.append({+ 'type': 'eq',+ 'fun': lambda w: np.dot(w, expected_returns) - constraints['target_return']+ })++ # Bounds for individual weights+ bounds = [+ (constraints.get('min_weight', -1), constraints.get('max_weight', 1))+ for _ in range(n_assets)+ ]++ # Initial guess (equal weights)+ initial_weights = np.array([1 / n_assets] * n_assets)++ try:+ result = minimize(+ objective_function,+ initial_weights,+ method='SLSQP',+ bounds=bounds,+ constraints=constraint_list+ )++ if result.success:+ optimal_weights = result.x+ optimal_return = np.dot(optimal_weights, expected_returns)+ optimal_variance = np.dot(optimal_weights.T, np.dot(covariance_matrix, optimal_weights))+ optimal_std = np.sqrt(optimal_variance)+ sharpe_ratio = optimal_return / optimal_std if optimal_std > 0 else 0++ return {+ 'success': True,+ 'optimal_weights': optimal_weights,+ 'expected_return': optimal_return,+ 'volatility': optimal_std,+ 'sharpe_ratio': sharpe_ratio,+ 'optimization_result': result+ }+ else:+ return {'success': False, 'message': result.message}++ except Exception as e:+ logger.error(f"Portfolio optimization failed: {e}")+ return {'success': False, 'message': str(e)}+++# Export main classes+__all__ = [+ 'RiskMeasure', 'ScenarioType', 'PortfolioPosition', 'RiskMetrics',+ 'ScenarioResult', 'SensitivityResult', 'DerivativesPortfolio',+ 'RiskAnalyzer', 'ScenarioAnalyzer', 'PerformanceAttribution', 'PortfolioOptimizer'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/arbitrage.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/arbitrage.pynew file mode 100644index 000000000..a15121f3b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/arbitrage.py@@ -0,0 +1,1060 @@+"""+Derivatives Arbitrage Detection Module+====================================++Comprehensive arbitrage detection and synthetic instrument construction framework for derivatives markets. Implements various arbitrage strategies including put-call parity violations, carry arbitrage, box spreads, and volatility arbitrage opportunities.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Real-time market prices for options and underlying assets+ - Option chain data (calls, puts across strikes and expirations)+ - Forward and futures prices for carry arbitrage analysis+ - Interest rate curves and dividend yield data+ - Implied volatility surfaces and historical volatility data+ - Market bid-ask spreads and liquidity metrics++OUTPUT:+ - Arbitrage opportunity detection across multiple strategies+ - Synthetic instrument construction and replication analysis+ - Profit potential calculations and confidence assessments+ - Execution plans and risk factor identification+ - Arbitrage opportunity ranking and filtering+ - Trade execution timing and monitoring requirements++PARAMETERS:+ - confidence_threshold: Minimum confidence level for opportunities - default: 0.05+ - tolerance: Price tolerance for arbitrage detection - default: Constants.EPSILON+ - min_profit: Minimum profit threshold for opportunities - default: 0.0+ - min_confidence: Minimum confidence level - default: 0.0+ - max_complexity: Maximum execution complexity - default: "high"+ - allowed_types: Specific arbitrage types to scan for+ - market_vol: Historical volatility for volatility arbitrage+ - implied_vol: Implied volatility for comparison+"""++import numpy as np+from typing import Dict, List, Tuple, Optional, NamedTuple+from datetime import datetime+from dataclasses import dataclass+from enum import Enum+import logging++from .core import (+ DerivativeType, OptionType, UnderlyingType, MarketData,+ PricingResult, ValidationError, ModelValidator, Constants+)+from .forward_commitments import CarryArbitrageCalculator+from .options import VanillaOption, PutCallParity, BlackScholesPricingEngine++logger = logging.getLogger(__name__)+++class ArbitrageType(Enum):+ """Types of arbitrage opportunities"""+ CARRY_ARBITRAGE = "carry_arbitrage"+ PUT_CALL_PARITY = "put_call_parity"+ FORWARD_PARITY = "forward_parity"+ BOX_SPREAD = "box_spread"+ CONVERSION = "conversion"+ REVERSAL = "reversal"+ CALENDAR_SPREAD = "calendar_spread"+ VOLATILITY_ARBITRAGE = "volatility_arbitrage"+++class ArbitrageDirection(Enum):+ """Direction of arbitrage trade"""+ BUY_CHEAP_SELL_EXPENSIVE = "buy_cheap_sell_expensive"+ SELL_EXPENSIVE_BUY_CHEAP = "sell_expensive_buy_cheap"+++@dataclass+class ArbitrageOpportunity:+ """Container for arbitrage opportunity details"""+ arbitrage_type: ArbitrageType+ direction: ArbitrageDirection+ profit_potential: float+ confidence_level: float+ instruments_involved: List[str]+ trade_details: Dict+ risk_factors: List[str]+ execution_complexity: str # "low", "medium", "high"++ def __post_init__(self):+ if self.profit_potential < 0:+ raise ValidationError("Profit potential cannot be negative")+ if not (0 <= self.confidence_level <= 1):+ raise ValidationError("Confidence level must be between 0 and 1")+++@dataclass+class SyntheticInstrument:+ """Synthetic instrument construction details"""+ target_instrument: str+ synthetic_components: List[Dict]+ cost_comparison: float+ replication_accuracy: float++ def __post_init__(self):+ if not (0 <= self.replication_accuracy <= 1):+ raise ValidationError("Replication accuracy must be between 0 and 1")+++class ConversionStrategy:+ """Conversion arbitrage strategy implementation"""++ def __init__(self, spot_price: float, strike_price: float,+ call_price: float, put_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0):++ self.spot_price = spot_price+ self.strike_price = strike_price+ self.call_price = call_price+ self.put_price = put_price+ self.risk_free_rate = risk_free_rate+ self.time_to_expiry = time_to_expiry+ self.dividend_yield = dividend_yield++ ModelValidator.validate_positive(spot_price, "spot_price")+ ModelValidator.validate_positive(strike_price, "strike_price")+ ModelValidator.validate_positive(call_price, "call_price")+ ModelValidator.validate_positive(put_price, "put_price")++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect conversion arbitrage opportunity"""+ # Calculate synthetic call using put-call parity+ pv_strike = self.strike_price * np.exp(-self.risk_free_rate * self.time_to_expiry)+ pv_spot = self.spot_price * np.exp(-self.dividend_yield * self.time_to_expiry)++ synthetic_call = self.put_price + pv_spot - pv_strike++ # Check for arbitrage+ price_difference = self.call_price - synthetic_call++ if abs(price_difference) > Constants.EPSILON:+ if price_difference > 0:+ # Call is overpriced - sell call, buy synthetic call+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CONVERSION,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=abs(price_difference),+ confidence_level=0.95,+ instruments_involved=["call", "put", "stock", "bond"],+ trade_details={+ "sell_call": self.call_price,+ "buy_put": self.put_price,+ "buy_stock": self.spot_price,+ "sell_bond": pv_strike,+ "net_profit": price_difference,+ "synthetic_call_price": synthetic_call,+ "actual_call_price": self.call_price+ },+ risk_factors=["early_exercise", "dividend_risk", "interest_rate_risk"],+ execution_complexity="medium"+ )+ else:+ # Call is underpriced - buy call, sell synthetic call+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.REVERSAL,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=abs(price_difference),+ confidence_level=0.95,+ instruments_involved=["call", "put", "stock", "bond"],+ trade_details={+ "buy_call": self.call_price,+ "sell_put": self.put_price,+ "sell_stock": self.spot_price,+ "buy_bond": pv_strike,+ "net_profit": abs(price_difference),+ "synthetic_call_price": synthetic_call,+ "actual_call_price": self.call_price+ },+ risk_factors=["early_exercise", "dividend_risk", "interest_rate_risk"],+ execution_complexity="medium"+ )++ return None+++class ReversalStrategy:+ """Reversal arbitrage strategy implementation"""++ def __init__(self, spot_price: float, strike_price: float,+ call_price: float, put_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0):++ self.spot_price = spot_price+ self.strike_price = strike_price+ self.call_price = call_price+ self.put_price = put_price+ self.risk_free_rate = risk_free_rate+ self.time_to_expiry = time_to_expiry+ self.dividend_yield = dividend_yield++ ModelValidator.validate_positive(spot_price, "spot_price")+ ModelValidator.validate_positive(strike_price, "strike_price")+ ModelValidator.validate_positive(call_price, "call_price")+ ModelValidator.validate_positive(put_price, "put_price")++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect reversal arbitrage opportunity"""+ # Calculate synthetic put using put-call parity+ pv_strike = self.strike_price * np.exp(-self.risk_free_rate * self.time_to_expiry)+ pv_spot = self.spot_price * np.exp(-self.dividend_yield * self.time_to_expiry)++ synthetic_put = self.call_price + pv_strike - pv_spot++ # Check for arbitrage+ price_difference = self.put_price - synthetic_put++ if abs(price_difference) > Constants.EPSILON:+ if price_difference > 0:+ # Put is overpriced - sell put, buy synthetic put+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.REVERSAL,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=abs(price_difference),+ confidence_level=0.95,+ instruments_involved=["call", "put", "stock", "bond"],+ trade_details={+ "buy_call": self.call_price,+ "sell_put": self.put_price,+ "sell_stock": self.spot_price,+ "buy_bond": pv_strike,+ "net_profit": price_difference,+ "synthetic_put_price": synthetic_put,+ "actual_put_price": self.put_price+ },+ risk_factors=["early_exercise", "dividend_risk", "interest_rate_risk"],+ execution_complexity="medium"+ )+ else:+ # Put is underpriced - buy put, sell synthetic put+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CONVERSION,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=abs(price_difference),+ confidence_level=0.95,+ instruments_involved=["call", "put", "stock", "bond"],+ trade_details={+ "sell_call": self.call_price,+ "buy_put": self.put_price,+ "buy_stock": self.spot_price,+ "sell_bond": pv_strike,+ "net_profit": abs(price_difference),+ "synthetic_put_price": synthetic_put,+ "actual_put_price": self.put_price+ },+ risk_factors=["early_exercise", "dividend_risk", "interest_rate_risk"],+ execution_complexity="medium"+ )++ return None+++class BoxSpreadStrategy:+ """Box spread arbitrage strategy"""++ def __init__(self, strike_low: float, strike_high: float,+ call_low_price: float, call_high_price: float,+ put_low_price: float, put_high_price: float,+ risk_free_rate: float, time_to_expiry: float):++ self.K1 = strike_low # Lower strike+ self.K2 = strike_high # Higher strike+ self.C1 = call_low_price # Call with lower strike+ self.C2 = call_high_price # Call with higher strike+ self.P1 = put_low_price # Put with lower strike+ self.P2 = put_high_price # Put with higher strike+ self.r = risk_free_rate+ self.T = time_to_expiry++ if strike_low >= strike_high:+ raise ValidationError("Lower strike must be less than higher strike")++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect box spread arbitrage"""+ # Box spread payoff is always (K2 - K1)+ guaranteed_payoff = self.K2 - self.K1+ present_value_payoff = guaranteed_payoff * np.exp(-self.r * self.T)++ # Cost of box spread = (C1 - C2) + (P2 - P1)+ box_cost = (self.C1 - self.C2) + (self.P2 - self.P1)++ # Arbitrage profit+ arbitrage_profit = present_value_payoff - box_cost++ if abs(arbitrage_profit) > Constants.EPSILON:+ if arbitrage_profit > 0:+ # Box is underpriced - buy box spread+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.BOX_SPREAD,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=arbitrage_profit,+ confidence_level=0.99, # Risk-free arbitrage+ instruments_involved=[f"call_{self.K1}", f"call_{self.K2}",+ f"put_{self.K1}", f"put_{self.K2}"],+ trade_details={+ "buy_call_low": self.C1,+ "sell_call_high": self.C2,+ "sell_put_low": self.P1,+ "buy_put_high": self.P2,+ "box_cost": box_cost,+ "guaranteed_payoff": guaranteed_payoff,+ "present_value": present_value_payoff,+ "arbitrage_profit": arbitrage_profit,+ "call_spread_cost": self.C1 - self.C2,+ "put_spread_cost": self.P2 - self.P1+ },+ risk_factors=["execution_risk", "bid_ask_spread"],+ execution_complexity="high"+ )+ else:+ # Box is overpriced - sell box spread+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.BOX_SPREAD,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=abs(arbitrage_profit),+ confidence_level=0.99,+ instruments_involved=[f"call_{self.K1}", f"call_{self.K2}",+ f"put_{self.K1}", f"put_{self.K2}"],+ trade_details={+ "sell_call_low": self.C1,+ "buy_call_high": self.C2,+ "buy_put_low": self.P1,+ "sell_put_high": self.P2,+ "box_revenue": -box_cost,+ "guaranteed_payout": -guaranteed_payoff,+ "arbitrage_profit": abs(arbitrage_profit),+ "call_spread_revenue": -(self.C1 - self.C2),+ "put_spread_revenue": -(self.P2 - self.P1)+ },+ risk_factors=["execution_risk", "bid_ask_spread"],+ execution_complexity="high"+ )++ return None+++class CarryArbitrageDetector:+ """Detect carry arbitrage opportunities in forwards/futures"""++ def __init__(self, spot_price: float, forward_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0, storage_cost: float = 0.0,+ convenience_yield: float = 0.0):++ self.spot_price = spot_price+ self.forward_price = forward_price+ self.risk_free_rate = risk_free_rate+ self.time_to_expiry = time_to_expiry+ self.dividend_yield = dividend_yield+ self.storage_cost = storage_cost+ self.convenience_yield = convenience_yield++ ModelValidator.validate_positive(spot_price, "spot_price")+ ModelValidator.validate_positive(forward_price, "forward_price")++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect carry arbitrage opportunity"""+ # Calculate theoretical forward price+ carry_rate = (self.risk_free_rate - self.dividend_yield ++ self.storage_cost - self.convenience_yield)++ theoretical_forward = self.spot_price * np.exp(carry_rate * self.time_to_expiry)++ # Check for arbitrage+ price_difference = self.forward_price - theoretical_forward++ if abs(price_difference) > Constants.EPSILON:+ # Present value of arbitrage profit+ arbitrage_profit = abs(price_difference) * np.exp(-self.risk_free_rate * self.time_to_expiry)++ if price_difference > 0:+ # Forward is overpriced - sell forward, buy underlying+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CARRY_ARBITRAGE,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=arbitrage_profit,+ confidence_level=0.90,+ instruments_involved=["forward", "underlying", "bond"],+ trade_details={+ "sell_forward": self.forward_price,+ "buy_underlying": self.spot_price,+ "borrow_funds": self.spot_price,+ "theoretical_forward": theoretical_forward,+ "price_difference": price_difference,+ "carry_rate": carry_rate,+ "dividend_yield": self.dividend_yield,+ "storage_cost": self.storage_cost,+ "convenience_yield": self.convenience_yield+ },+ risk_factors=["storage_costs", "convenience_yield", "dividend_changes", "interest_rate_risk"],+ execution_complexity="medium"+ )+ else:+ # Forward is underpriced - buy forward, sell underlying+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CARRY_ARBITRAGE,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=arbitrage_profit,+ confidence_level=0.90,+ instruments_involved=["forward", "underlying", "bond"],+ trade_details={+ "buy_forward": self.forward_price,+ "sell_underlying": self.spot_price,+ "invest_proceeds": self.spot_price,+ "theoretical_forward": theoretical_forward,+ "price_difference": price_difference,+ "carry_rate": carry_rate,+ "dividend_yield": self.dividend_yield,+ "storage_cost": self.storage_cost,+ "convenience_yield": self.convenience_yield+ },+ risk_factors=["storage_costs", "convenience_yield", "dividend_changes", "interest_rate_risk"],+ execution_complexity="medium"+ )++ return None+++class VolatilityArbitrageDetector:+ """Detect volatility arbitrage opportunities"""++ def __init__(self, market_vol: float, implied_vol: float,+ option: VanillaOption, market_data: MarketData,+ confidence_threshold: float = 0.05):++ self.market_vol = market_vol+ self.implied_vol = implied_vol+ self.option = option+ self.market_data = market_data+ self.confidence_threshold = confidence_threshold++ ModelValidator.validate_volatility(market_vol)+ ModelValidator.validate_volatility(implied_vol)++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect volatility arbitrage based on vol differential"""+ vol_difference = self.implied_vol - self.market_vol+ vol_spread_pct = abs(vol_difference) / self.market_vol++ if vol_spread_pct > self.confidence_threshold:+ # Calculate option values at different volatilities+ market_data_market_vol = MarketData(+ spot_price=self.market_data.spot_price,+ risk_free_rate=self.market_data.risk_free_rate,+ dividend_yield=self.market_data.dividend_yield,+ volatility=self.market_vol,+ time_to_expiry=self.market_data.time_to_expiry+ )++ engine = BlackScholesPricingEngine()+ market_vol_price = engine.price(self.option, market_data_market_vol).fair_value++ market_data_implied_vol = MarketData(+ spot_price=self.market_data.spot_price,+ risk_free_rate=self.market_data.risk_free_rate,+ dividend_yield=self.market_data.dividend_yield,+ volatility=self.implied_vol,+ time_to_expiry=self.market_data.time_to_expiry+ )++ implied_vol_price = engine.price(self.option, market_data_implied_vol).fair_value++ price_difference = implied_vol_price - market_vol_price++ if vol_difference > 0:+ # Implied vol > realized vol - sell option, delta hedge+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.VOLATILITY_ARBITRAGE,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=abs(price_difference),+ confidence_level=min(0.95, vol_spread_pct * 5), # Higher spread = higher confidence+ instruments_involved=["option", "underlying"],+ trade_details={+ "sell_option": implied_vol_price,+ "market_vol": self.market_vol,+ "implied_vol": self.implied_vol,+ "vol_difference": vol_difference,+ "price_difference": price_difference,+ "strategy": "sell_option_delta_hedge",+ "vol_spread_pct": vol_spread_pct,+ "market_vol_price": market_vol_price,+ "implied_vol_price": implied_vol_price+ },+ risk_factors=["gamma_risk", "vol_risk", "time_decay", "model_risk"],+ execution_complexity="high"+ )+ else:+ # Implied vol < realized vol - buy option, delta hedge+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.VOLATILITY_ARBITRAGE,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=abs(price_difference),+ confidence_level=min(0.95, vol_spread_pct * 5),+ instruments_involved=["option", "underlying"],+ trade_details={+ "buy_option": implied_vol_price,+ "market_vol": self.market_vol,+ "implied_vol": self.implied_vol,+ "vol_difference": vol_difference,+ "price_difference": price_difference,+ "strategy": "buy_option_delta_hedge",+ "vol_spread_pct": vol_spread_pct,+ "market_vol_price": market_vol_price,+ "implied_vol_price": implied_vol_price+ },+ risk_factors=["gamma_risk", "vol_risk", "time_decay", "model_risk"],+ execution_complexity="high"+ )++ return None+++class CalendarSpreadArbitrage:+ """Calendar spread arbitrage detector"""++ def __init__(self, near_option_price: float, far_option_price: float,+ near_time_to_expiry: float, far_time_to_expiry: float,+ strike_price: float, option_type: OptionType,+ market_data: MarketData):++ self.near_option_price = near_option_price+ self.far_option_price = far_option_price+ self.near_time = near_time_to_expiry+ self.far_time = far_time_to_expiry+ self.strike_price = strike_price+ self.option_type = option_type+ self.market_data = market_data++ if near_time_to_expiry >= far_time_to_expiry:+ raise ValidationError("Near expiry must be less than far expiry")++ def detect_arbitrage(self) -> Optional[ArbitrageOpportunity]:+ """Detect calendar spread arbitrage"""+ # Calculate theoretical time decay value+ time_decay_value = self.far_option_price - self.near_option_price++ # Calculate theoretical time decay using Black-Scholes+ engine = BlackScholesPricingEngine()++ near_option = VanillaOption(+ option_type=self.option_type,+ underlying_type=UnderlyingType.EQUITY,+ expiry_date=datetime.now(),+ strike_price=self.strike_price+ )++ far_option = VanillaOption(+ option_type=self.option_type,+ underlying_type=UnderlyingType.EQUITY,+ expiry_date=datetime.now(),+ strike_price=self.strike_price+ )++ # Create market data for different times+ near_market_data = MarketData(+ spot_price=self.market_data.spot_price,+ risk_free_rate=self.market_data.risk_free_rate,+ dividend_yield=self.market_data.dividend_yield,+ volatility=self.market_data.volatility,+ time_to_expiry=self.near_time+ )++ far_market_data = MarketData(+ spot_price=self.market_data.spot_price,+ risk_free_rate=self.market_data.risk_free_rate,+ dividend_yield=self.market_data.dividend_yield,+ volatility=self.market_data.volatility,+ time_to_expiry=self.far_time+ )++ theoretical_near_price = engine.price(near_option, near_market_data).fair_value+ theoretical_far_price = engine.price(far_option, far_market_data).fair_value+ theoretical_time_decay = theoretical_far_price - theoretical_near_price++ # Check for arbitrage+ price_difference = time_decay_value - theoretical_time_decay++ if abs(price_difference) > Constants.EPSILON:+ if price_difference > 0:+ # Calendar spread is overpriced - sell calendar spread+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CALENDAR_SPREAD,+ direction=ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP,+ profit_potential=abs(price_difference),+ confidence_level=0.80,+ instruments_involved=[f"{self.option_type.value}_near", f"{self.option_type.value}_far"],+ trade_details={+ "sell_far_option": self.far_option_price,+ "buy_near_option": self.near_option_price,+ "calendar_spread_cost": time_decay_value,+ "theoretical_time_decay": theoretical_time_decay,+ "arbitrage_profit": price_difference,+ "near_time": self.near_time,+ "far_time": self.far_time+ },+ risk_factors=["volatility_risk", "time_decay", "pin_risk"],+ execution_complexity="medium"+ )+ else:+ # Calendar spread is underpriced - buy calendar spread+ return ArbitrageOpportunity(+ arbitrage_type=ArbitrageType.CALENDAR_SPREAD,+ direction=ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE,+ profit_potential=abs(price_difference),+ confidence_level=0.80,+ instruments_involved=[f"{self.option_type.value}_near", f"{self.option_type.value}_far"],+ trade_details={+ "buy_far_option": self.far_option_price,+ "sell_near_option": self.near_option_price,+ "calendar_spread_cost": time_decay_value,+ "theoretical_time_decay": theoretical_time_decay,+ "arbitrage_profit": abs(price_difference),+ "near_time": self.near_time,+ "far_time": self.far_time+ },+ risk_factors=["volatility_risk", "time_decay", "pin_risk"],+ execution_complexity="medium"+ )++ return None+++class SyntheticInstrumentBuilder:+ """Build synthetic instruments using replication strategies"""++ @staticmethod+ def synthetic_call(put_price: float, spot_price: float, strike_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0) -> SyntheticInstrument:+ """Create synthetic call using put-call parity: C = P + S - K*e^(-rT)"""+ pv_strike = strike_price * np.exp(-risk_free_rate * time_to_expiry)+ pv_spot = spot_price * np.exp(-dividend_yield * time_to_expiry)++ synthetic_call_price = put_price + pv_spot - pv_strike++ return SyntheticInstrument(+ target_instrument="call",+ synthetic_components=[+ {"instrument": "put", "position": "long", "price": put_price, "quantity": 1},+ {"instrument": "stock", "position": "long", "price": spot_price, "quantity": 1},+ {"instrument": "bond", "position": "short", "price": pv_strike, "quantity": 1}+ ],+ cost_comparison=synthetic_call_price,+ replication_accuracy=0.99+ )++ @staticmethod+ def synthetic_put(call_price: float, spot_price: float, strike_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0) -> SyntheticInstrument:+ """Create synthetic put using put-call parity: P = C + K*e^(-rT) - S"""+ pv_strike = strike_price * np.exp(-risk_free_rate * time_to_expiry)+ pv_spot = spot_price * np.exp(-dividend_yield * time_to_expiry)++ synthetic_put_price = call_price + pv_strike - pv_spot++ return SyntheticInstrument(+ target_instrument="put",+ synthetic_components=[+ {"instrument": "call", "position": "long", "price": call_price, "quantity": 1},+ {"instrument": "bond", "position": "long", "price": pv_strike, "quantity": 1},+ {"instrument": "stock", "position": "short", "price": spot_price, "quantity": 1}+ ],+ cost_comparison=synthetic_put_price,+ replication_accuracy=0.99+ )++ @staticmethod+ def synthetic_stock(call_price: float, put_price: float, strike_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0) -> SyntheticInstrument:+ """Create synthetic stock using options: S = C - P + K*e^(-rT)"""+ pv_strike = strike_price * np.exp(-risk_free_rate * time_to_expiry)++ synthetic_stock_price = call_price - put_price + pv_strike++ return SyntheticInstrument(+ target_instrument="stock",+ synthetic_components=[+ {"instrument": "call", "position": "long", "price": call_price, "quantity": 1},+ {"instrument": "put", "position": "short", "price": put_price, "quantity": 1},+ {"instrument": "bond", "position": "long", "price": pv_strike, "quantity": 1}+ ],+ cost_comparison=synthetic_stock_price,+ replication_accuracy=0.95+ )++ @staticmethod+ def synthetic_forward(spot_price: float, risk_free_rate: float,+ time_to_expiry: float, dividend_yield: float = 0.0) -> SyntheticInstrument:+ """Create synthetic forward position: F = S*e^((r-q)*T)"""+ pv_dividends = spot_price * (1 - np.exp(-dividend_yield * time_to_expiry))+ borrowing_cost = (spot_price - pv_dividends) * (np.exp(risk_free_rate * time_to_expiry) - 1)++ forward_price = spot_price * np.exp((risk_free_rate - dividend_yield) * time_to_expiry)++ return SyntheticInstrument(+ target_instrument="forward",+ synthetic_components=[+ {"instrument": "stock", "position": "long", "price": spot_price, "quantity": 1},+ {"instrument": "bond", "position": "short", "price": spot_price - pv_dividends, "quantity": 1}+ ],+ cost_comparison=forward_price,+ replication_accuracy=0.99+ )++ @staticmethod+ def synthetic_bond(strike_price: float, call_price: float, put_price: float,+ spot_price: float, dividend_yield: float = 0.0) -> SyntheticInstrument:+ """Create synthetic bond using put-call parity: Bond = C - P + S"""+ synthetic_bond_price = strike_price+ cost_to_replicate = call_price - put_price + spot_price * np.exp(-dividend_yield)++ return SyntheticInstrument(+ target_instrument="bond",+ synthetic_components=[+ {"instrument": "call", "position": "long", "price": call_price, "quantity": 1},+ {"instrument": "put", "position": "short", "price": put_price, "quantity": 1},+ {"instrument": "stock", "position": "long", "price": spot_price, "quantity": 1}+ ],+ cost_comparison=cost_to_replicate,+ replication_accuracy=0.98+ )+++class ArbitrageScanner:+ """Comprehensive arbitrage opportunity scanner"""++ def __init__(self, tolerance: float = Constants.EPSILON):+ self.tolerance = tolerance+ self.detected_opportunities = []++ def scan_put_call_parity(self, call_price: float, put_price: float,+ spot_price: float, strike_price: float,+ risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0) -> List[ArbitrageOpportunity]:+ """Scan for put-call parity arbitrage"""+ opportunities = []++ # Check conversion strategy+ conversion = ConversionStrategy(+ spot_price, strike_price, call_price, put_price,+ risk_free_rate, time_to_expiry, dividend_yield+ )++ conversion_opportunity = conversion.detect_arbitrage()+ if conversion_opportunity:+ opportunities.append(conversion_opportunity)++ # Check reversal strategy+ reversal = ReversalStrategy(+ spot_price, strike_price, call_price, put_price,+ risk_free_rate, time_to_expiry, dividend_yield+ )++ reversal_opportunity = reversal.detect_arbitrage()+ if reversal_opportunity:+ opportunities.append(reversal_opportunity)++ return opportunities++ def scan_carry_arbitrage(self, spot_price: float, forward_price: float,+ risk_free_rate: float, time_to_expiry: float,+ **kwargs) -> List[ArbitrageOpportunity]:+ """Scan for carry arbitrage opportunities"""+ opportunities = []++ detector = CarryArbitrageDetector(+ spot_price, forward_price, risk_free_rate, time_to_expiry, **kwargs+ )++ opportunity = detector.detect_arbitrage()+ if opportunity:+ opportunities.append(opportunity)++ return opportunities++ def scan_box_spread(self, strikes: Tuple[float, float],+ call_prices: Tuple[float, float],+ put_prices: Tuple[float, float],+ risk_free_rate: float, time_to_expiry: float) -> List[ArbitrageOpportunity]:+ """Scan for box spread arbitrage"""+ opportunities = []++ box_spread = BoxSpreadStrategy(+ strikes[0], strikes[1], call_prices[0], call_prices[1],+ put_prices[0], put_prices[1], risk_free_rate, time_to_expiry+ )++ opportunity = box_spread.detect_arbitrage()+ if opportunity:+ opportunities.append(opportunity)++ return opportunities++ def scan_volatility_arbitrage(self, market_vol: float, implied_vol: float,+ option: VanillaOption, market_data: MarketData,+ confidence_threshold: float = 0.05) -> List[ArbitrageOpportunity]:+ """Scan for volatility arbitrage opportunities"""+ opportunities = []++ detector = VolatilityArbitrageDetector(+ market_vol, implied_vol, option, market_data, confidence_threshold+ )++ opportunity = detector.detect_arbitrage()+ if opportunity:+ opportunities.append(opportunity)++ return opportunities++ def scan_calendar_spread(self, near_option_price: float, far_option_price: float,+ near_time: float, far_time: float, strike_price: float,+ option_type: OptionType, market_data: MarketData) -> List[ArbitrageOpportunity]:+ """Scan for calendar spread arbitrage"""+ opportunities = []++ detector = CalendarSpreadArbitrage(+ near_option_price, far_option_price, near_time, far_time,+ strike_price, option_type, market_data+ )++ opportunity = detector.detect_arbitrage()+ if opportunity:+ opportunities.append(opportunity)++ return opportunities++ def comprehensive_scan(self, market_data: Dict) -> List[ArbitrageOpportunity]:+ """Perform comprehensive arbitrage scan"""+ all_opportunities = []++ try:+ # Put-call parity scan+ if all(key in market_data for key in ['call_price', 'put_price', 'spot_price', 'strike_price']):+ pcp_opportunities = self.scan_put_call_parity(+ market_data['call_price'], market_data['put_price'],+ market_data['spot_price'], market_data['strike_price'],+ market_data.get('risk_free_rate', 0.02),+ market_data.get('time_to_expiry', 0.25),+ market_data.get('dividend_yield', 0.0)+ )+ all_opportunities.extend(pcp_opportunities)++ # Carry arbitrage scan+ if all(key in market_data for key in ['spot_price', 'forward_price']):+ carry_opportunities = self.scan_carry_arbitrage(+ market_data['spot_price'], market_data['forward_price'],+ market_data.get('risk_free_rate', 0.02),+ market_data.get('time_to_expiry', 0.25),+ dividend_yield=market_data.get('dividend_yield', 0.0),+ storage_cost=market_data.get('storage_cost', 0.0),+ convenience_yield=market_data.get('convenience_yield', 0.0)+ )+ all_opportunities.extend(carry_opportunities)++ # Box spread scan+ if all(key in market_data for key in ['strikes', 'call_prices', 'put_prices']):+ box_opportunities = self.scan_box_spread(+ market_data['strikes'], market_data['call_prices'],+ market_data['put_prices'],+ market_data.get('risk_free_rate', 0.02),+ market_data.get('time_to_expiry', 0.25)+ )+ all_opportunities.extend(box_opportunities)++ # Volatility arbitrage scan+ if all(key in market_data for key in ['market_vol', 'implied_vol', 'option']):+ vol_opportunities = self.scan_volatility_arbitrage(+ market_data['market_vol'], market_data['implied_vol'],+ market_data['option'], market_data.get('market_data_obj'),+ market_data.get('confidence_threshold', 0.05)+ )+ all_opportunities.extend(vol_opportunities)++ # Calendar spread scan+ if all(key in market_data for key in ['near_option_price', 'far_option_price', 'near_time', 'far_time']):+ calendar_opportunities = self.scan_calendar_spread(+ market_data['near_option_price'], market_data['far_option_price'],+ market_data['near_time'], market_data['far_time'],+ market_data.get('strike_price', 100),+ market_data.get('option_type', OptionType.CALL),+ market_data.get('market_data_obj')+ )+ all_opportunities.extend(calendar_opportunities)++ except Exception as e:+ logger.error(f"Error in arbitrage scan: {e}")++ self.detected_opportunities = all_opportunities+ return all_opportunities++ def rank_opportunities(self, opportunities: List[ArbitrageOpportunity]) -> List[ArbitrageOpportunity]:+ """Rank arbitrage opportunities by attractiveness"""++ def opportunity_score(opp):+ # Score based on profit potential, confidence, and execution complexity+ complexity_weights = {"low": 1.0, "medium": 0.7, "high": 0.5}+ complexity_weight = complexity_weights.get(opp.execution_complexity, 0.5)++ # Base score: profit * confidence * complexity adjustment+ base_score = opp.profit_potential * opp.confidence_level * complexity_weight++ # Bonus for risk-free arbitrage (box spreads)+ if opp.arbitrage_type == ArbitrageType.BOX_SPREAD and opp.confidence_level >= 0.99:+ base_score *= 1.5++ # Penalty for high-risk strategies+ if len(opp.risk_factors) > 3:+ base_score *= 0.8++ return base_score++ return sorted(opportunities, key=opportunity_score, reverse=True)++ def filter_opportunities(self, opportunities: List[ArbitrageOpportunity],+ min_profit: float = 0.0, min_confidence: float = 0.0,+ max_complexity: str = "high",+ allowed_types: List[ArbitrageType] = None) -> List[ArbitrageOpportunity]:+ """Filter opportunities based on criteria"""+ filtered = []++ complexity_levels = {"low": 1, "medium": 2, "high": 3}+ max_complexity_level = complexity_levels.get(max_complexity, 3)++ for opp in opportunities:+ # Check profit threshold+ if opp.profit_potential < min_profit:+ continue++ # Check confidence threshold+ if opp.confidence_level < min_confidence:+ continue++ # Check complexity+ opp_complexity_level = complexity_levels.get(opp.execution_complexity, 3)+ if opp_complexity_level > max_complexity_level:+ continue++ # Check allowed types+ if allowed_types and opp.arbitrage_type not in allowed_types:+ continue++ filtered.append(opp)++ return filtered++ def generate_execution_plan(self, opportunity: ArbitrageOpportunity) -> Dict[str, Any]:+ """Generate detailed execution plan for arbitrage opportunity"""+ execution_steps = []++ if opportunity.arbitrage_type == ArbitrageType.CONVERSION:+ execution_steps = [+ {"step": 1, "action": "Sell call option", "details": opportunity.trade_details.get("sell_call")},+ {"step": 2, "action": "Buy put option", "details": opportunity.trade_details.get("buy_put")},+ {"step": 3, "action": "Buy underlying stock", "details": opportunity.trade_details.get("buy_stock")},+ {"step": 4, "action": "Sell bonds (borrow)", "details": opportunity.trade_details.get("sell_bond")}+ ]+ elif opportunity.arbitrage_type == ArbitrageType.REVERSAL:+ execution_steps = [+ {"step": 1, "action": "Buy call option", "details": opportunity.trade_details.get("buy_call")},+ {"step": 2, "action": "Sell put option", "details": opportunity.trade_details.get("sell_put")},+ {"step": 3, "action": "Sell underlying stock", "details": opportunity.trade_details.get("sell_stock")},+ {"step": 4, "action": "Buy bonds (lend)", "details": opportunity.trade_details.get("buy_bond")}+ ]+ elif opportunity.arbitrage_type == ArbitrageType.BOX_SPREAD:+ if opportunity.direction == ArbitrageDirection.BUY_CHEAP_SELL_EXPENSIVE:+ execution_steps = [+ {"step": 1, "action": "Buy call (low strike)",+ "details": opportunity.trade_details.get("buy_call_low")},+ {"step": 2, "action": "Sell call (high strike)",+ "details": opportunity.trade_details.get("sell_call_high")},+ {"step": 3, "action": "Sell put (low strike)",+ "details": opportunity.trade_details.get("sell_put_low")},+ {"step": 4, "action": "Buy put (high strike)",+ "details": opportunity.trade_details.get("buy_put_high")}+ ]+ else:+ execution_steps = [+ {"step": 1, "action": "Sell call (low strike)",+ "details": opportunity.trade_details.get("sell_call_low")},+ {"step": 2, "action": "Buy call (high strike)",+ "details": opportunity.trade_details.get("buy_call_high")},+ {"step": 3, "action": "Buy put (low strike)",+ "details": opportunity.trade_details.get("buy_put_low")},+ {"step": 4, "action": "Sell put (high strike)",+ "details": opportunity.trade_details.get("sell_put_high")}+ ]+ elif opportunity.arbitrage_type == ArbitrageType.CARRY_ARBITRAGE:+ if opportunity.direction == ArbitrageDirection.SELL_EXPENSIVE_BUY_CHEAP:+ execution_steps = [+ {"step": 1, "action": "Sell forward contract",+ "details": opportunity.trade_details.get("sell_forward")},+ {"step": 2, "action": "Buy underlying asset",+ "details": opportunity.trade_details.get("buy_underlying")},+ {"step": 3, "action": "Borrow funds", "details": opportunity.trade_details.get("borrow_funds")}+ ]+ else:+ execution_steps = [+ {"step": 1, "action": "Buy forward contract",+ "details": opportunity.trade_details.get("buy_forward")},+ {"step": 2, "action": "Sell underlying asset",+ "details": opportunity.trade_details.get("sell_underlying")},+ {"step": 3, "action": "Invest proceeds",+ "details": opportunity.trade_details.get("invest_proceeds")}+ ]++ return {+ "opportunity_id": f"{opportunity.arbitrage_type.value}_{datetime.now().strftime('%Y%m%d_%H%M%S')}",+ "execution_steps": execution_steps,+ "estimated_profit": opportunity.profit_potential,+ "confidence_level": opportunity.confidence_level,+ "risk_factors": opportunity.risk_factors,+ "execution_complexity": opportunity.execution_complexity,+ "required_capital": self._calculate_required_capital(opportunity),+ "time_to_expiration": opportunity.trade_details.get("time_to_expiry", "N/A"),+ "monitoring_requirements": self._get_monitoring_requirements(opportunity)+ }++ def _calculate_required_capital(self, opportunity: ArbitrageOpportunity) -> float:+ """Calculate required capital for arbitrage execution"""+ # Simplified calculation - in practice would be more sophisticated+ if opportunity.arbitrage_type in [ArbitrageType.CONVERSION, ArbitrageType.REVERSAL]:+ return opportunity.trade_details.get("buy_stock", 0) + opportunity.trade_details.get("buy_put", 0)+ elif opportunity.arbitrage_type == ArbitrageType.BOX_SPREAD:+ return opportunity.trade_details.get("box_cost", 0)+ elif opportunity.arbitrage_type == ArbitrageType.CARRY_ARBITRAGE:+ return opportunity.trade_details.get("buy_underlying", 0)+ else:+ return 0.0++ def _get_monitoring_requirements(self, opportunity: ArbitrageOpportunity) -> List[str]:+ """Get monitoring requirements for arbitrage position"""+ monitoring = ["market_prices", "position_delta"]++ if opportunity.arbitrage_type == ArbitrageType.VOLATILITY_ARBITRAGE:+ monitoring.extend(["realized_volatility", "implied_volatility", "gamma_exposure"])++ if opportunity.arbitrage_type in [ArbitrageType.CONVERSION, ArbitrageType.REVERSAL]:+ monitoring.extend(["dividend_announcements", "early_exercise_risk"])++ if opportunity.arbitrage_type == ArbitrageType.CARRY_ARBITRAGE:+ monitoring.extend(["interest_rates", "storage_costs", "convenience_yield"])++ if opportunity.arbitrage_type == ArbitrageType.CALENDAR_SPREAD:+ monitoring.extend(["time_decay", "pin_risk", "volatility_term_structure"])++ return monitoring+++# Export main classes+__all__ = [+ 'ArbitrageType', 'ArbitrageDirection', 'ArbitrageOpportunity', 'SyntheticInstrument',+ 'ConversionStrategy', 'ReversalStrategy', 'BoxSpreadStrategy', 'CarryArbitrageDetector',+ 'VolatilityArbitrageDetector', 'CalendarSpreadArbitrage', 'SyntheticInstrumentBuilder',+ 'ArbitrageScanner'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/core.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/core.pynew file mode 100644index 000000000..7895a7221--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/core.py@@ -0,0 +1,422 @@+"""+Derivatives Core Analytics Module+===============================++Core framework for derivatives analytics providing foundational classes, data structures, and validation utilities. Implements CFA Institute standard methodologies for derivative pricing, risk measurement, and portfolio management.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Market data including spot prices, interest rates, dividend yields+ - Volatility surfaces and option pricing parameters+ - Derivative instrument specifications (strike, expiry, type)+ - Day count conventions and calendar data+ - Interest rate curves and yield curves+ - Corporate actions and event data++OUTPUT:+ - Standardized derivative instrument representations+ - Market data validation and processing+ - Pricing result containers and calculations+ - Time calculations using various day count conventions+ - Interest rate conversion utilities+ - Model validation and error handling++PARAMETERS:+ - spot_price: Current spot price of underlying asset+ - risk_free_rate: Risk-free interest rate+ - dividend_yield: Dividend yield for the underlying+ - volatility: Volatility parameter for pricing models+ - time_to_expiry: Time to expiration in years+ - strike_price: Strike price for options+ - notional: Contract notional amount - default: 1.0+ - day_count: Day count convention - default: DayCountConvention.ACT_365+ - from_compounding: Source rate compounding method+ - to_compounding: Target rate compounding method+ - frequency: Compounding frequency for discrete rates+"""++from abc import ABC, abstractmethod+from enum import Enum+from dataclasses import dataclass+from typing import Optional, Union, Dict, Any, List+from datetime import datetime, date+import numpy as np+import logging++# Configure logging+logging.basicConfig(level=logging.INFO)+logger = logging.getLogger(__name__)+++class DerivativeType(Enum):+ """Classification of derivative instruments"""+ FORWARD = "forward"+ FUTURE = "future"+ SWAP = "swap"+ OPTION = "option"+ CREDIT_DERIVATIVE = "credit_derivative"+++class OptionType(Enum):+ """Option contract types"""+ CALL = "call"+ PUT = "put"+++class Position(Enum):+ """Trading position direction"""+ LONG = "long"+ SHORT = "short"+++class ExerciseStyle(Enum):+ """Option exercise styles"""+ EUROPEAN = "european"+ AMERICAN = "american"+ BERMUDAN = "bermudan"+++class UnderlyingType(Enum):+ """Types of underlying assets"""+ EQUITY = "equity"+ BOND = "bond"+ COMMODITY = "commodity"+ CURRENCY = "currency"+ INTEREST_RATE = "interest_rate"+ INDEX = "index"+++class DayCountConvention(Enum):+ """Day count conventions for financial calculations"""+ ACT_360 = "ACT/360"+ ACT_365 = "ACT/365"+ THIRTY_360 = "30/360"+ ACT_ACT = "ACT/ACT"+++@dataclass+class MarketData:+ """Market data container for derivative pricing"""+ spot_price: float+ risk_free_rate: float+ dividend_yield: float = 0.0+ volatility: float = 0.0+ time_to_expiry: float = 0.0+ strike_price: Optional[float] = None+ forward_price: Optional[float] = None++ def __post_init__(self):+ """Validate market data inputs"""+ if self.spot_price <= 0:+ raise ValueError("Spot price must be positive")+ if self.volatility < 0:+ raise ValueError("Volatility cannot be negative")+ if self.time_to_expiry < 0:+ raise ValueError("Time to expiry cannot be negative")+++@dataclass+class PricingResult:+ """Container for derivative pricing results"""+ fair_value: float+ intrinsic_value: Optional[float] = None+ time_value: Optional[float] = None+ greeks: Optional[Dict[str, float]] = None+ confidence_interval: Optional[tuple] = None+ calculation_details: Optional[Dict[str, Any]] = None++ def __post_init__(self):+ """Calculate derived values"""+ if self.intrinsic_value is not None and self.time_value is None:+ self.time_value = self.fair_value - self.intrinsic_value+++class ValidationError(Exception):+ """Custom exception for validation errors"""+ pass+++class PricingError(Exception):+ """Custom exception for pricing calculation errors"""+ pass+++class DerivativeInstrument(ABC):+ """+ Abstract base class for all derivative instruments.+ Implements common interface following CFA curriculum structure.+ """++ def __init__(self,+ derivative_type: DerivativeType,+ underlying_type: UnderlyingType,+ expiry_date: Union[datetime, date],+ notional: float = 1.0,+ day_count: DayCountConvention = DayCountConvention.ACT_365):++ self.derivative_type = derivative_type+ self.underlying_type = underlying_type+ self.expiry_date = expiry_date+ self.notional = notional+ self.day_count = day_count+ self.creation_date = datetime.now()++ self._validate_inputs()++ def _validate_inputs(self):+ """Validate instrument parameters"""+ if self.notional <= 0:+ raise ValidationError("Notional amount must be positive")++ if isinstance(self.expiry_date, date):+ self.expiry_date = datetime.combine(self.expiry_date, datetime.min.time())++ if self.expiry_date <= self.creation_date:+ raise ValidationError("Expiry date must be in the future")++ @abstractmethod+ def calculate_payoff(self, spot_price: float) -> float:+ """Calculate payoff at expiration given spot price"""+ pass++ @abstractmethod+ def fair_value(self, market_data: MarketData) -> PricingResult:+ """Calculate fair value using appropriate pricing model"""+ pass++ def time_to_expiry(self, valuation_date: Optional[datetime] = None) -> float:+ """Calculate time to expiry in years"""+ if valuation_date is None:+ valuation_date = datetime.now()++ time_diff = self.expiry_date - valuation_date++ if self.day_count == DayCountConvention.ACT_365:+ return time_diff.total_seconds() / (365.25 * 24 * 3600)+ elif self.day_count == DayCountConvention.ACT_360:+ return time_diff.total_seconds() / (360 * 24 * 3600)+ elif self.day_count == DayCountConvention.THIRTY_360:+ return time_diff.days / 360+ else: # ACT_ACT+ return time_diff.total_seconds() / (365.25 * 24 * 3600)++ def is_expired(self, valuation_date: Optional[datetime] = None) -> bool:+ """Check if derivative has expired"""+ if valuation_date is None:+ valuation_date = datetime.now()+ return valuation_date >= self.expiry_date++ def __repr__(self) -> str:+ return f"{self.__class__.__name__}(type={self.derivative_type.value}, expiry={self.expiry_date})"+++class ForwardCommitment(DerivativeInstrument):+ """Base class for forward commitments (forwards, futures, swaps)"""++ def __init__(self,+ derivative_type: DerivativeType,+ underlying_type: UnderlyingType,+ expiry_date: Union[datetime, date],+ contract_price: float,+ notional: float = 1.0,+ day_count: DayCountConvention = DayCountConvention.ACT_365):+ super().__init__(derivative_type, underlying_type, expiry_date, notional, day_count)+ self.contract_price = contract_price++ if contract_price <= 0:+ raise ValidationError("Contract price must be positive")+++class ContingentClaim(DerivativeInstrument):+ """Base class for contingent claims (options)"""++ def __init__(self,+ option_type: OptionType,+ underlying_type: UnderlyingType,+ expiry_date: Union[datetime, date],+ strike_price: float,+ exercise_style: ExerciseStyle = ExerciseStyle.EUROPEAN,+ notional: float = 1.0,+ day_count: DayCountConvention = DayCountConvention.ACT_365):++ super().__init__(DerivativeType.OPTION, underlying_type, expiry_date, notional, day_count)+ self.option_type = option_type+ self.strike_price = strike_price+ self.exercise_style = exercise_style++ if strike_price <= 0:+ raise ValidationError("Strike price must be positive")++ def moneyness(self, spot_price: float) -> str:+ """Determine option moneyness"""+ if self.option_type == OptionType.CALL:+ if spot_price > self.strike_price:+ return "ITM" # In-the-money+ elif spot_price == self.strike_price:+ return "ATM" # At-the-money+ else:+ return "OTM" # Out-of-the-money+ else: # PUT+ if spot_price < self.strike_price:+ return "ITM"+ elif spot_price == self.strike_price:+ return "ATM"+ else:+ return "OTM"++ def intrinsic_value(self, spot_price: float) -> float:+ """Calculate intrinsic value of option"""+ if self.option_type == OptionType.CALL:+ return max(0, spot_price - self.strike_price)+ else: # PUT+ return max(0, self.strike_price - spot_price)+++class PricingEngine(ABC):+ """Abstract base class for pricing engines"""++ @abstractmethod+ def price(self, instrument: DerivativeInstrument, market_data: MarketData) -> PricingResult:+ """Price derivative instrument"""+ pass++ @abstractmethod+ def validate_inputs(self, instrument: DerivativeInstrument, market_data: MarketData) -> bool:+ """Validate inputs for pricing"""+ pass+++class ModelValidator:+ """Validation utilities for derivative models"""++ @staticmethod+ def validate_probability(prob: float) -> bool:+ """Validate probability is between 0 and 1"""+ return 0 <= prob <= 1++ @staticmethod+ def validate_positive(value: float, name: str) -> bool:+ """Validate value is positive"""+ if value <= 0:+ raise ValidationError(f"{name} must be positive, got {value}")+ return True++ @staticmethod+ def validate_non_negative(value: float, name: str) -> bool:+ """Validate value is non-negative"""+ if value < 0:+ raise ValidationError(f"{name} cannot be negative, got {value}")+ return True++ @staticmethod+ def validate_rate(rate: float, name: str) -> bool:+ """Validate interest rate (can be negative in modern markets)"""+ if abs(rate) > 1.0: # More than 100% is suspicious+ logger.warning(f"{name} is unusually high: {rate * 100:.2f}%")+ return True++ @staticmethod+ def validate_volatility(vol: float) -> bool:+ """Validate volatility parameter"""+ if vol < 0:+ raise ValidationError(f"Volatility cannot be negative, got {vol}")+ if vol > 5.0: # 500% volatility is extreme+ logger.warning(f"Volatility is extremely high: {vol * 100:.2f}%")+ return True+++class Constants:+ """Mathematical and financial constants"""++ # Numerical precision+ EPSILON = 1e-10+ MAX_ITERATIONS = 10000++ # Financial constants+ TRADING_DAYS_PER_YEAR = 252+ CALENDAR_DAYS_PER_YEAR = 365.25++ # Default model parameters+ DEFAULT_RISK_FREE_RATE = 0.02+ DEFAULT_VOLATILITY = 0.20+ DEFAULT_DIVIDEND_YIELD = 0.0++ # Greeks calculation parameters+ BUMP_SIZE = 0.01 # 1% for delta, gamma calculations+ VOL_BUMP = 0.01 # 1% for vega calculations+ TIME_BUMP = 1 / 365 # 1 day for theta calculations+++def calculate_time_fraction(start_date: datetime,+ end_date: datetime,+ day_count: DayCountConvention = DayCountConvention.ACT_365) -> float:+ """+ Calculate time fraction between dates using specified day count convention++ Args:+ start_date: Start date+ end_date: End date+ day_count: Day count convention++ Returns:+ Time fraction in years+ """+ if end_date <= start_date:+ return 0.0++ time_diff = end_date - start_date++ if day_count == DayCountConvention.ACT_365:+ return time_diff.total_seconds() / (365.25 * 24 * 3600)+ elif day_count == DayCountConvention.ACT_360:+ return time_diff.total_seconds() / (360 * 24 * 3600)+ elif day_count == DayCountConvention.THIRTY_360:+ return time_diff.days / 360+ else: # ACT_ACT+ return time_diff.total_seconds() / (365.25 * 24 * 3600)+++def risk_free_rate_converter(rate: float,+ from_compounding: str = "continuous",+ to_compounding: str = "continuous",+ frequency: int = 1) -> float:+ """+ Convert between different interest rate compounding conventions++ Args:+ rate: Input interest rate+ from_compounding: Source compounding ('continuous', 'annual', 'discrete')+ to_compounding: Target compounding ('continuous', 'annual', 'discrete')+ frequency: Compounding frequency for discrete rates++ Returns:+ Converted interest rate+ """+ # Convert to continuous first+ if from_compounding == "continuous":+ continuous_rate = rate+ elif from_compounding == "annual":+ continuous_rate = np.log(1 + rate)+ elif from_compounding == "discrete":+ continuous_rate = frequency * np.log(1 + rate / frequency)+ else:+ raise ValueError(f"Unknown compounding type: {from_compounding}")++ # Convert from continuous to target+ if to_compounding == "continuous":+ return continuous_rate+ elif to_compounding == "annual":+ return np.exp(continuous_rate) - 1+ elif to_compounding == "discrete":+ return frequency * (np.exp(continuous_rate / frequency) - 1)+ else:+ raise ValueError(f"Unknown compounding type: {to_compounding}")+++# Export main classes and functions+__all__ = [+ 'DerivativeType', 'OptionType', 'Position', 'ExerciseStyle', 'UnderlyingType',+ 'DayCountConvention', 'MarketData', 'PricingResult', 'ValidationError', 'PricingError',+ 'DerivativeInstrument', 'ForwardCommitment', 'ContingentClaim', 'PricingEngine',+ 'ModelValidator', 'Constants', 'calculate_time_fraction', 'risk_free_rate_converter'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/forward_commitments.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/forward_commitments.pynew file mode 100644index 000000000..05acf73f9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/forward_commitments.py@@ -0,0 +1,613 @@+"""+Forward Commitments Analytics Module+===================================++Comprehensive pricing and valuation framework for forward commitments including forwards, futures, and swaps. Implements CFA Institute standard carry arbitrage models and pricing methodologies for various derivative types.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Spot prices for underlying assets+ - Risk-free interest rate curves and yields+ - Dividend yields and payment schedules+ - Storage costs and convenience yields for commodities+ - Repo rates and borrowing costs for financing+ - Fixed income instrument details and coupon schedules+ - Currency exchange rates for cross-currency swaps++OUTPUT:+ - Forward and futures contract valuations+ - Interest rate swap pricing and par rate calculations+ - Currency swap fair value assessments+ - Equity swap payment calculations+ - Carry arbitrage opportunity analysis+ - Forward rate agreement (FRA) valuations++PARAMETERS:+ - spot_price: Current spot price of underlying+ - contract_price: Forward contract price+ - risk_free_rate: Risk-free interest rate+ - dividend_yield: Continuous dividend yield - default: 0.0+ - storage_cost: Storage cost rate - default: 0.0+ - convenience_yield: Convenience yield - default: 0.0+ - notional: Contract notional amount+ - day_count: Day count convention - default: DayCountConvention.ACT_365+ - currency: Contract currency - default: "USD"+ - payment_frequency: Swap payment frequency - default: 0.25 (quarterly)+"""++import numpy as np+from typing import Optional, List, Dict, Tuple+from datetime import datetime, date+from dataclasses import dataclass+import logging++from .core import (+ ForwardCommitment, DerivativeType, UnderlyingType, DayCountConvention,+ MarketData, PricingResult, PricingEngine, ValidationError, ModelValidator,+ Constants, calculate_time_fraction+)+from .market_data import MarketDataManager, CurveData, YieldCurvePoint++logger = logging.getLogger(__name__)+++@dataclass+class CarryModel:+ """Carry arbitrage model parameters"""+ spot_price: float+ risk_free_rate: float+ dividend_yield: float = 0.0+ storage_cost: float = 0.0+ convenience_yield: float = 0.0+ repo_rate: Optional[float] = None+ borrow_cost: Optional[float] = None++ def __post_init__(self):+ ModelValidator.validate_positive(self.spot_price, "spot_price")+ ModelValidator.validate_rate(self.risk_free_rate, "risk_free_rate")+ ModelValidator.validate_non_negative(self.dividend_yield, "dividend_yield")+ ModelValidator.validate_non_negative(self.storage_cost, "storage_cost")+ ModelValidator.validate_non_negative(self.convenience_yield, "convenience_yield")++ @property+ def net_carry_rate(self) -> float:+ """Calculate net carry rate"""+ carry_rate = self.risk_free_rate - self.dividend_yield + self.storage_cost - self.convenience_yield++ if self.repo_rate is not None:+ carry_rate = self.repo_rate - self.dividend_yield + self.storage_cost - self.convenience_yield++ if self.borrow_cost is not None:+ carry_rate += self.borrow_cost++ return carry_rate+++class EquityForward(ForwardCommitment):+ """Equity forward contract implementation"""++ def __init__(self,+ underlying_symbol: str,+ expiry_date: datetime,+ contract_price: float,+ notional: float = 1.0,+ day_count: DayCountConvention = DayCountConvention.ACT_365):+ super().__init__(+ DerivativeType.FORWARD,+ UnderlyingType.EQUITY,+ expiry_date,+ contract_price,+ notional,+ day_count+ )+ self.underlying_symbol = underlying_symbol++ def calculate_payoff(self, spot_price: float) -> float:+ """Calculate payoff at expiration"""+ return self.notional * (spot_price - self.contract_price)++ def fair_value(self, market_data: MarketData) -> PricingResult:+ """Calculate fair value using carry arbitrage model"""+ time_to_expiry = self.time_to_expiry()++ # Carry arbitrage model: F = S * e^((r-q)*T)+ carry_rate = market_data.risk_free_rate - market_data.dividend_yield+ theoretical_forward_price = market_data.spot_price * np.exp(carry_rate * time_to_expiry)++ # Value = (F_market - F_theoretical) * e^(-r*T) * notional+ discount_factor = np.exp(-market_data.risk_free_rate * time_to_expiry)+ fair_value = (self.contract_price - theoretical_forward_price) * discount_factor * self.notional++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "theoretical_forward_price": theoretical_forward_price,+ "market_forward_price": self.contract_price,+ "carry_rate": carry_rate,+ "discount_factor": discount_factor,+ "time_to_expiry": time_to_expiry+ }+ )+++class InterestRateForward(ForwardCommitment):+ """Interest rate forward contract (FRA - Forward Rate Agreement)"""++ def __init__(self,+ start_date: datetime,+ end_date: datetime,+ contract_rate: float,+ notional: float = 1000000, # $1M standard+ day_count: DayCountConvention = DayCountConvention.ACT_360,+ currency: str = "USD"):++ super().__init__(+ DerivativeType.FORWARD,+ UnderlyingType.INTEREST_RATE,+ end_date,+ contract_rate,+ notional,+ day_count+ )+ self.start_date = start_date+ self.currency = currency++ if start_date >= end_date:+ raise ValidationError("Start date must be before end date")++ def calculate_payoff(self, market_rate: float) -> float:+ """Calculate FRA payoff at settlement"""+ period_length = calculate_time_fraction(self.start_date, self.expiry_date, self.day_count)+ rate_diff = market_rate - self.contract_price++ # FRA payoff discounted to settlement date+ payoff = (rate_diff * period_length * self.notional) / (1 + market_rate * period_length)+ return payoff++ def fair_value(self, market_data: MarketData) -> PricingResult:+ """Calculate FRA fair value using forward rates"""+ # Get yield curve from market data manager+ data_manager = MarketDataManager()+ yield_curve = data_manager.primary_provider.get_yield_curve(self.currency)++ # Calculate forward rate+ t1 = calculate_time_fraction(datetime.now(), self.start_date, self.day_count)+ t2 = calculate_time_fraction(datetime.now(), self.expiry_date, self.day_count)++ r1 = yield_curve.interpolate_rate(t1)+ r2 = yield_curve.interpolate_rate(t2)++ # Forward rate formula: F = ((1 + r2*T2) / (1 + r1*T1) - 1) / (T2 - T1)+ if self.day_count == DayCountConvention.ACT_360:+ forward_rate = ((1 + r2 * t2) / (1 + r1 * t1) - 1) / (t2 - t1)+ else:+ # For continuous compounding+ forward_rate = (r2 * t2 - r1 * t1) / (t2 - t1)++ # FRA value+ period_length = calculate_time_fraction(self.start_date, self.expiry_date, self.day_count)+ rate_diff = forward_rate - self.contract_price+ discount_factor = np.exp(-r1 * t1)++ fair_value = (rate_diff * period_length * self.notional * discount_factor) / (1 + forward_rate * period_length)++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "forward_rate": forward_rate,+ "contract_rate": self.contract_price,+ "period_length": period_length,+ "t1": t1,+ "t2": t2,+ "r1": r1,+ "r2": r2,+ "discount_factor": discount_factor+ }+ )+++class FixedIncomeForward(ForwardCommitment):+ """Fixed income forward contract"""++ def __init__(self,+ bond_details: Dict,+ expiry_date: datetime,+ contract_price: float,+ notional: float = 100, # Par value+ day_count: DayCountConvention = DayCountConvention.ACT_365):++ super().__init__(+ DerivativeType.FORWARD,+ UnderlyingType.BOND,+ expiry_date,+ contract_price,+ notional,+ day_count+ )+ self.bond_details = bond_details+ self.coupon_rate = bond_details.get("coupon_rate", 0.0)+ self.face_value = bond_details.get("face_value", 100)+ self.maturity_date = bond_details.get("maturity_date")++ def calculate_payoff(self, bond_price: float) -> float:+ """Calculate payoff at expiration"""+ return self.notional * (bond_price - self.contract_price)++ def fair_value(self, market_data: MarketData) -> PricingResult:+ """Calculate fair value with accrued interest consideration"""+ time_to_expiry = self.time_to_expiry()++ # Calculate present value of coupons between now and forward expiry+ coupon_pv = self._calculate_coupon_pv(market_data.risk_free_rate, time_to_expiry)++ # Forward price: F = (S - PV_coupons) * e^(r*T)+ adjusted_spot = market_data.spot_price - coupon_pv+ theoretical_forward_price = adjusted_spot * np.exp(market_data.risk_free_rate * time_to_expiry)++ discount_factor = np.exp(-market_data.risk_free_rate * time_to_expiry)+ fair_value = (self.contract_price - theoretical_forward_price) * discount_factor * self.notional++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "theoretical_forward_price": theoretical_forward_price,+ "coupon_pv": coupon_pv,+ "adjusted_spot_price": adjusted_spot,+ "time_to_expiry": time_to_expiry+ }+ )++ def _calculate_coupon_pv(self, risk_free_rate: float, time_to_expiry: float) -> float:+ """Calculate present value of coupons paid during forward period"""+ # Simplified: assume semi-annual coupons+ annual_coupon = self.coupon_rate * self.face_value+ semi_annual_coupon = annual_coupon / 2++ coupon_pv = 0.0+ coupon_frequency = 0.5 # Semi-annual++ # Calculate PV of coupons paid before forward expiry+ for i in range(1, int(time_to_expiry / coupon_frequency) + 1):+ coupon_time = i * coupon_frequency+ if coupon_time <= time_to_expiry:+ coupon_pv += semi_annual_coupon * np.exp(-risk_free_rate * coupon_time)++ return coupon_pv+++class InterestRateSwap:+ """Interest Rate Swap implementation"""++ def __init__(self,+ notional: float,+ fixed_rate: float,+ floating_rate_index: str,+ start_date: datetime,+ end_date: datetime,+ payment_frequency: float = 0.25, # Quarterly+ day_count: DayCountConvention = DayCountConvention.ACT_360,+ currency: str = "USD"):++ self.notional = notional+ self.fixed_rate = fixed_rate+ self.floating_rate_index = floating_rate_index+ self.start_date = start_date+ self.end_date = end_date+ self.payment_frequency = payment_frequency+ self.day_count = day_count+ self.currency = currency++ ModelValidator.validate_positive(notional, "notional")+ ModelValidator.validate_rate(fixed_rate, "fixed_rate")++ def fair_value(self, yield_curve: CurveData, pay_fixed: bool = True) -> PricingResult:+ """Calculate swap fair value using yield curve"""+ payment_dates = self._generate_payment_dates()++ # Calculate fixed leg PV+ fixed_leg_pv = 0.0+ for payment_date in payment_dates:+ time_to_payment = calculate_time_fraction(datetime.now(), payment_date, self.day_count)+ discount_rate = yield_curve.interpolate_rate(time_to_payment)+ discount_factor = np.exp(-discount_rate * time_to_payment)++ period_length = self.payment_frequency+ fixed_payment = self.fixed_rate * period_length * self.notional+ fixed_leg_pv += fixed_payment * discount_factor++ # Calculate floating leg PV (simplified)+ floating_leg_pv = self.notional * (1 - np.exp(-yield_curve.interpolate_rate(+ calculate_time_fraction(datetime.now(), self.end_date, self.day_count)+ ) * calculate_time_fraction(datetime.now(), self.end_date, self.day_count)))++ # Swap value depends on position+ if pay_fixed:+ fair_value = floating_leg_pv - fixed_leg_pv+ else:+ fair_value = fixed_leg_pv - floating_leg_pv++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "fixed_leg_pv": fixed_leg_pv,+ "floating_leg_pv": floating_leg_pv,+ "pay_fixed": pay_fixed,+ "payment_dates": len(payment_dates)+ }+ )++ def _generate_payment_dates(self) -> List[datetime]:+ """Generate payment dates for swap"""+ payment_dates = []+ current_date = self.start_date++ while current_date < self.end_date:+ # Add payment frequency in years converted to days+ days_to_add = int(self.payment_frequency * 365.25)+ next_date = current_date.replace(day=current_date.day + days_to_add)++ # Simplified date handling - in production use proper business day calendar+ if next_date <= self.end_date:+ payment_dates.append(next_date)+ current_date = next_date++ return payment_dates++ def par_rate(self, yield_curve: CurveData) -> float:+ """Calculate par swap rate (market swap rate)"""+ payment_dates = self._generate_payment_dates()++ # Calculate annuity factor (sum of discount factors)+ annuity_factor = 0.0+ for payment_date in payment_dates:+ time_to_payment = calculate_time_fraction(datetime.now(), payment_date, self.day_count)+ discount_rate = yield_curve.interpolate_rate(time_to_payment)+ discount_factor = np.exp(-discount_rate * time_to_payment)+ annuity_factor += discount_factor * self.payment_frequency++ # Par rate = (1 - final_discount_factor) / annuity_factor+ final_time = calculate_time_fraction(datetime.now(), self.end_date, self.day_count)+ final_discount_factor = np.exp(-yield_curve.interpolate_rate(final_time) * final_time)++ par_rate = (1 - final_discount_factor) / annuity_factor+ return par_rate+++class CurrencySwap:+ """Currency Swap implementation"""++ def __init__(self,+ notional_domestic: float,+ notional_foreign: float,+ fixed_rate_domestic: float,+ fixed_rate_foreign: float,+ start_date: datetime,+ end_date: datetime,+ domestic_currency: str = "USD",+ foreign_currency: str = "EUR",+ payment_frequency: float = 0.5): # Semi-annual++ self.notional_domestic = notional_domestic+ self.notional_foreign = notional_foreign+ self.fixed_rate_domestic = fixed_rate_domestic+ self.fixed_rate_foreign = fixed_rate_foreign+ self.start_date = start_date+ self.end_date = end_date+ self.domestic_currency = domestic_currency+ self.foreign_currency = foreign_currency+ self.payment_frequency = payment_frequency++ ModelValidator.validate_positive(notional_domestic, "domestic_notional")+ ModelValidator.validate_positive(notional_foreign, "foreign_notional")++ def fair_value(self,+ domestic_curve: CurveData,+ foreign_curve: CurveData,+ fx_rate: float) -> PricingResult:+ """Calculate currency swap fair value"""++ # Calculate domestic leg PV+ domestic_leg_pv = self._calculate_leg_pv(+ self.notional_domestic,+ self.fixed_rate_domestic,+ domestic_curve+ )++ # Calculate foreign leg PV in foreign currency+ foreign_leg_pv_foreign = self._calculate_leg_pv(+ self.notional_foreign,+ self.fixed_rate_foreign,+ foreign_curve+ )++ # Convert foreign leg to domestic currency+ foreign_leg_pv_domestic = foreign_leg_pv_foreign * fx_rate++ # Swap value = Foreign leg PV - Domestic leg PV+ fair_value = foreign_leg_pv_domestic - domestic_leg_pv++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "domestic_leg_pv": domestic_leg_pv,+ "foreign_leg_pv_foreign": foreign_leg_pv_foreign,+ "foreign_leg_pv_domestic": foreign_leg_pv_domestic,+ "fx_rate": fx_rate+ }+ )++ def _calculate_leg_pv(self, notional: float, fixed_rate: float, yield_curve: CurveData) -> float:+ """Calculate present value of one leg"""+ total_time = calculate_time_fraction(self.start_date, self.end_date, DayCountConvention.ACT_365)+ num_payments = int(total_time / self.payment_frequency)++ leg_pv = 0.0+ for i in range(1, num_payments + 1):+ payment_time = i * self.payment_frequency+ discount_rate = yield_curve.interpolate_rate(payment_time)+ discount_factor = np.exp(-discount_rate * payment_time)++ coupon_payment = fixed_rate * self.payment_frequency * notional+ leg_pv += coupon_payment * discount_factor++ # Add principal repayment at maturity+ final_discount_rate = yield_curve.interpolate_rate(total_time)+ final_discount_factor = np.exp(-final_discount_rate * total_time)+ leg_pv += notional * final_discount_factor++ return leg_pv+++class EquitySwap:+ """Equity Swap implementation"""++ def __init__(self,+ notional: float,+ equity_leg_return: str, # "total_return" or "price_return"+ fixed_rate: Optional[float] = None,+ floating_rate_spread: float = 0.0,+ start_date: datetime = None,+ end_date: datetime = None,+ payment_frequency: float = 0.25): # Quarterly++ self.notional = notional+ self.equity_leg_return = equity_leg_return+ self.fixed_rate = fixed_rate+ self.floating_rate_spread = floating_rate_spread+ self.start_date = start_date or datetime.now()+ self.end_date = end_date+ self.payment_frequency = payment_frequency++ ModelValidator.validate_positive(notional, "notional")++ def calculate_equity_leg_payment(self,+ initial_price: float,+ final_price: float,+ dividends: float = 0.0) -> float:+ """Calculate equity leg payment"""+ price_return = (final_price - initial_price) / initial_price++ if self.equity_leg_return == "total_return":+ total_return = price_return + dividends / initial_price+ return self.notional * total_return+ else: # price_return only+ return self.notional * price_return++ def calculate_fixed_leg_payment(self, period_length: float) -> float:+ """Calculate fixed leg payment"""+ if self.fixed_rate is None:+ raise ValueError("Fixed rate not specified for equity swap")+ return self.notional * self.fixed_rate * period_length++ def fair_value(self, market_data: MarketData, expected_equity_return: float) -> PricingResult:+ """Calculate equity swap fair value"""+ time_to_expiry = calculate_time_fraction(self.start_date, self.end_date, DayCountConvention.ACT_365)++ # Expected equity leg PV+ expected_equity_pv = self.notional * expected_equity_return * np.exp(+ -market_data.risk_free_rate * time_to_expiry)++ # Fixed leg PV+ if self.fixed_rate is not None:+ total_fixed_payments = self.fixed_rate * time_to_expiry * self.notional+ fixed_leg_pv = total_fixed_payments * np.exp(-market_data.risk_free_rate * time_to_expiry)+ else:+ # Floating leg approximation+ fixed_leg_pv = self.notional * (market_data.risk_free_rate + self.floating_rate_spread) * time_to_expiry+ fixed_leg_pv *= np.exp(-market_data.risk_free_rate * time_to_expiry)++ fair_value = expected_equity_pv - fixed_leg_pv++ return PricingResult(+ fair_value=fair_value,+ calculation_details={+ "expected_equity_pv": expected_equity_pv,+ "fixed_leg_pv": fixed_leg_pv,+ "expected_equity_return": expected_equity_return,+ "time_to_expiry": time_to_expiry+ }+ )+++class CarryArbitrageCalculator:+ """Carry arbitrage model calculations"""++ @staticmethod+ def forward_price_no_income(spot: float, risk_free_rate: float, time_to_expiry: float) -> float:+ """Forward price with no income from underlying"""+ return spot * np.exp(risk_free_rate * time_to_expiry)++ @staticmethod+ def forward_price_with_yield(spot: float, risk_free_rate: float, yield_rate: float, time_to_expiry: float) -> float:+ """Forward price with continuous yield from underlying"""+ return spot * np.exp((risk_free_rate - yield_rate) * time_to_expiry)++ @staticmethod+ def forward_price_with_discrete_income(spot: float, risk_free_rate: float, income_pv: float,+ time_to_expiry: float) -> float:+ """Forward price with discrete income payments"""+ return (spot - income_pv) * np.exp(risk_free_rate * time_to_expiry)++ @staticmethod+ def forward_price_with_storage_cost(spot: float, risk_free_rate: float, storage_cost_rate: float,+ time_to_expiry: float) -> float:+ """Forward price with storage costs"""+ return spot * np.exp((risk_free_rate + storage_cost_rate) * time_to_expiry)++ @staticmethod+ def forward_price_commodity(spot: float, risk_free_rate: float, storage_cost_rate: float, convenience_yield: float,+ time_to_expiry: float) -> float:+ """Forward price for commodities with storage costs and convenience yield"""+ net_cost = risk_free_rate + storage_cost_rate - convenience_yield+ return spot * np.exp(net_cost * time_to_expiry)++ @staticmethod+ def arbitrage_profit(forward_market_price: float, forward_theoretical_price: float, risk_free_rate: float,+ time_to_expiry: float) -> float:+ """Calculate arbitrage profit"""+ price_diff = forward_market_price - forward_theoretical_price+ return price_diff * np.exp(-risk_free_rate * time_to_expiry)+++class ForwardCommitmentPricingEngine(PricingEngine):+ """Unified pricing engine for forward commitments"""++ def __init__(self):+ self.carry_calculator = CarryArbitrageCalculator()++ def price(self, instrument: ForwardCommitment, market_data: MarketData) -> PricingResult:+ """Price forward commitment based on type"""+ if not self.validate_inputs(instrument, market_data):+ raise ValidationError("Invalid inputs for forward commitment pricing")++ if isinstance(instrument, EquityForward):+ return instrument.fair_value(market_data)+ elif isinstance(instrument, InterestRateForward):+ return instrument.fair_value(market_data)+ elif isinstance(instrument, FixedIncomeForward):+ return instrument.fair_value(market_data)+ else:+ raise ValueError(f"Unsupported forward commitment type: {type(instrument)}")++ def validate_inputs(self, instrument: ForwardCommitment, market_data: MarketData) -> bool:+ """Validate inputs for forward commitment pricing"""+ try:+ ModelValidator.validate_positive(market_data.spot_price, "spot_price")+ ModelValidator.validate_rate(market_data.risk_free_rate, "risk_free_rate")+ ModelValidator.validate_non_negative(market_data.dividend_yield, "dividend_yield")++ if instrument.is_expired():+ logger.warning("Forward commitment has expired")+ return False++ return True+ except ValidationError:+ return False+++# Export main classes+__all__ = [+ 'CarryModel', 'EquityForward', 'InterestRateForward', 'FixedIncomeForward',+ 'InterestRateSwap', 'CurrencySwap', 'EquitySwap', 'CarryArbitrageCalculator',+ 'ForwardCommitmentPricingEngine'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/market_data.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/market_data.pynew file mode 100644index 000000000..b0f4d5510--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/market_data.py@@ -0,0 +1,506 @@+"""+Market Data Management Module+============================++Provider-agnostic abstraction layer for market data management supporting derivatives pricing across multiple data sources. Implements unified API interfaces for real-time and historical market data retrieval, caching, and validation.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Real-time market data feeds from external providers+ - Historical price and volatility data series+ - Interest rate curves and yield curve data+ - Dividend payment histories and forecasts+ - Corporate action data and event information+ - Market liquidity and bid-ask spread data+ - Provider-specific API credentials and connections++OUTPUT:+ - Standardized market data snapshots for pricing+ - Validated and cleaned market data series+ - Interpolated yield curves and volatility surfaces+ - Cached market data with expiration management+ - Fallback data from alternative providers+ - Market data quality and validation metrics++PARAMETERS:+ - provider_name: Data provider identifier+ - symbol: Financial instrument ticker or identifier+ - currency: Currency code for market data - default: "USD"+ - maturity: Time to maturity in years+ - curve_type: Yield curve type - default: "government"+ - max_age_seconds: Cache expiration time - default: 300+ - data_frequency: Data update frequency+ - interpolation_method: Curve interpolation method - default: "linear"+"""++from abc import ABC, abstractmethod+from typing import Dict, List, Optional, Union, Any+from datetime import datetime, date+from dataclasses import dataclass, field+import numpy as np+import pandas as pd+import logging+from enum import Enum++from .core import (+ UnderlyingType, DayCountConvention, ValidationError,+ ModelValidator, calculate_time_fraction+)++logger = logging.getLogger(__name__)+++class DataProvider(Enum):+ """Supported market data providers"""+ BLOOMBERG = "bloomberg"+ REFINITIV = "refinitiv"+ YAHOO = "yahoo"+ ALPHA_VANTAGE = "alpha_vantage"+ MANUAL = "manual"+ CACHED = "cached"+++class DataFrequency(Enum):+ """Data frequency options"""+ REAL_TIME = "real_time"+ MINUTE = "1min"+ HOURLY = "1hour"+ DAILY = "1day"+ WEEKLY = "1week"+ MONTHLY = "1month"+++@dataclass+class YieldCurvePoint:+ """Single point on yield curve"""+ maturity: float # Years+ rate: float # Interest rate+ instrument_type: str = "government" # government, corporate, swap++ def __post_init__(self):+ ModelValidator.validate_non_negative(self.maturity, "maturity")+ ModelValidator.validate_rate(self.rate, "interest rate")+++@dataclass+class VolatilitySurfacePoint:+ """Single point on volatility surface"""+ strike: float+ time_to_expiry: float+ implied_volatility: float+ delta: Optional[float] = None++ def __post_init__(self):+ ModelValidator.validate_positive(self.strike, "strike")+ ModelValidator.validate_non_negative(self.time_to_expiry, "time_to_expiry")+ ModelValidator.validate_volatility(self.implied_volatility)+++@dataclass+class MarketSnapshot:+ """Complete market data snapshot for pricing"""+ timestamp: datetime+ spot_price: float+ risk_free_rate: float+ dividend_yield: float = 0.0+ repo_rate: Optional[float] = None+ borrow_cost: Optional[float] = None+ yield_curve: Optional[List[YieldCurvePoint]] = None+ volatility_surface: Optional[List[VolatilitySurfacePoint]] = None+ bid_ask_spread: Optional[float] = None++ def __post_init__(self):+ ModelValidator.validate_positive(self.spot_price, "spot_price")+ ModelValidator.validate_rate(self.risk_free_rate, "risk_free_rate")+ ModelValidator.validate_non_negative(self.dividend_yield, "dividend_yield")+++@dataclass+class CurveData:+ """Interest rate curve data"""+ curve_date: datetime+ curve_type: str # government, swap, corporate+ currency: str+ day_count: DayCountConvention+ points: List[YieldCurvePoint] = field(default_factory=list)++ def add_point(self, maturity: float, rate: float, instrument_type: str = "government"):+ """Add point to curve"""+ self.points.append(YieldCurvePoint(maturity, rate, instrument_type))+ self.points.sort(key=lambda x: x.maturity)++ def interpolate_rate(self, maturity: float, method: str = "linear") -> float:+ """Interpolate rate for given maturity"""+ if not self.points:+ raise ValueError("No curve points available")++ # Sort points by maturity+ sorted_points = sorted(self.points, key=lambda x: x.maturity)++ # Handle edge cases+ if maturity <= sorted_points[0].maturity:+ return sorted_points[0].rate+ if maturity >= sorted_points[-1].maturity:+ return sorted_points[-1].rate++ # Find interpolation points+ for i in range(len(sorted_points) - 1):+ if sorted_points[i].maturity <= maturity <= sorted_points[i + 1].maturity:+ if method == "linear":+ return self._linear_interpolation(+ sorted_points[i], sorted_points[i + 1], maturity+ )+ elif method == "cubic":+ return self._cubic_interpolation(sorted_points, maturity, i)++ raise ValueError(f"Cannot interpolate rate for maturity {maturity}")++ def _linear_interpolation(self, p1: YieldCurvePoint, p2: YieldCurvePoint, maturity: float) -> float:+ """Linear interpolation between two points"""+ if p2.maturity == p1.maturity:+ return p1.rate++ weight = (maturity - p1.maturity) / (p2.maturity - p1.maturity)+ return p1.rate + weight * (p2.rate - p1.rate)++ def _cubic_interpolation(self, points: List[YieldCurvePoint], maturity: float, index: int) -> float:+ """Cubic spline interpolation (simplified)"""+ # For simplicity, use linear interpolation+ # In production, implement proper cubic spline+ return self._linear_interpolation(points[index], points[index + 1], maturity)+++class MarketDataProvider(ABC):+ """Abstract base class for market data providers"""++ def __init__(self, provider_name: DataProvider):+ self.provider_name = provider_name+ self.connection_status = False+ self.last_update = None++ @abstractmethod+ def connect(self, **kwargs) -> bool:+ """Establish connection to data provider"""+ pass++ @abstractmethod+ def disconnect(self) -> bool:+ """Disconnect from data provider"""+ pass++ @abstractmethod+ def get_spot_price(self, symbol: str) -> float:+ """Get current spot price"""+ pass++ @abstractmethod+ def get_risk_free_rate(self, currency: str = "USD", maturity: float = 0.25) -> float:+ """Get risk-free rate for given currency and maturity"""+ pass++ @abstractmethod+ def get_dividend_yield(self, symbol: str) -> float:+ """Get dividend yield for equity"""+ pass++ @abstractmethod+ def get_volatility(self, symbol: str, maturity: float, strike: float = None) -> float:+ """Get implied volatility"""+ pass++ @abstractmethod+ def get_yield_curve(self, currency: str, curve_type: str = "government") -> CurveData:+ """Get complete yield curve"""+ pass+++class ManualDataProvider(MarketDataProvider):+ """Manual data input provider for custom scenarios"""++ def __init__(self):+ super().__init__(DataProvider.MANUAL)+ self.data_cache = {}+ self.connection_status = True++ def connect(self, **kwargs) -> bool:+ self.connection_status = True+ return True++ def disconnect(self) -> bool:+ self.connection_status = False+ return True++ def set_spot_price(self, symbol: str, price: float):+ """Manually set spot price"""+ ModelValidator.validate_positive(price, f"spot price for {symbol}")+ self.data_cache[f"spot_{symbol}"] = price+ self.last_update = datetime.now()++ def set_risk_free_rate(self, rate: float, currency: str = "USD", maturity: float = 0.25):+ """Manually set risk-free rate"""+ ModelValidator.validate_rate(rate, f"risk-free rate for {currency}")+ self.data_cache[f"rf_{currency}_{maturity}"] = rate+ self.last_update = datetime.now()++ def set_dividend_yield(self, symbol: str, yield_rate: float):+ """Manually set dividend yield"""+ ModelValidator.validate_non_negative(yield_rate, f"dividend yield for {symbol}")+ self.data_cache[f"div_{symbol}"] = yield_rate+ self.last_update = datetime.now()++ def set_volatility(self, symbol: str, volatility: float, maturity: float = None, strike: float = None):+ """Manually set volatility"""+ ModelValidator.validate_volatility(volatility)+ key = f"vol_{symbol}"+ if maturity is not None:+ key += f"_{maturity}"+ if strike is not None:+ key += f"_{strike}"+ self.data_cache[key] = volatility+ self.last_update = datetime.now()++ def get_spot_price(self, symbol: str) -> float:+ key = f"spot_{symbol}"+ if key not in self.data_cache:+ raise ValueError(f"No spot price data for symbol: {symbol}")+ return self.data_cache[key]++ def get_risk_free_rate(self, currency: str = "USD", maturity: float = 0.25) -> float:+ key = f"rf_{currency}_{maturity}"+ if key not in self.data_cache:+ # Try default rate+ default_key = f"rf_{currency}_0.25"+ if default_key in self.data_cache:+ return self.data_cache[default_key]+ # Use global default+ return 0.02 # 2% default+ return self.data_cache[key]++ def get_dividend_yield(self, symbol: str) -> float:+ key = f"div_{symbol}"+ return self.data_cache.get(key, 0.0) # Default to 0%++ def get_volatility(self, symbol: str, maturity: float, strike: float = None) -> float:+ # Try exact match first+ key = f"vol_{symbol}_{maturity}"+ if strike is not None:+ key += f"_{strike}"++ if key in self.data_cache:+ return self.data_cache[key]++ # Try without strike+ key_no_strike = f"vol_{symbol}_{maturity}"+ if key_no_strike in self.data_cache:+ return self.data_cache[key_no_strike]++ # Try generic volatility+ generic_key = f"vol_{symbol}"+ if generic_key in self.data_cache:+ return self.data_cache[generic_key]++ # Default volatility+ return 0.20 # 20% default++ def get_yield_curve(self, currency: str, curve_type: str = "government") -> CurveData:+ """Get yield curve (simplified for manual input)"""+ curve = CurveData(+ curve_date=datetime.now(),+ curve_type=curve_type,+ currency=currency,+ day_count=DayCountConvention.ACT_365+ )++ # Add default curve points if none exist+ default_rates = [+ (0.25, 0.02), (0.5, 0.022), (1.0, 0.025), (2.0, 0.028),+ (5.0, 0.032), (10.0, 0.035), (30.0, 0.038)+ ]++ for maturity, rate in default_rates:+ rf_rate = self.get_risk_free_rate(currency, maturity)+ curve.add_point(maturity, rf_rate)++ return curve+++class YahooFinanceProvider(MarketDataProvider):+ """Yahoo Finance data provider (simplified implementation)"""++ def __init__(self):+ super().__init__(DataProvider.YAHOO)+ self.api_key = None++ def connect(self, **kwargs) -> bool:+ """Connect to Yahoo Finance"""+ try:+ # In real implementation, establish connection+ self.connection_status = True+ logger.info("Connected to Yahoo Finance")+ return True+ except Exception as e:+ logger.error(f"Failed to connect to Yahoo Finance: {e}")+ return False++ def disconnect(self) -> bool:+ self.connection_status = False+ return True++ def get_spot_price(self, symbol: str) -> float:+ """Get spot price from Yahoo Finance"""+ if not self.connection_status:+ raise ConnectionError("Not connected to Yahoo Finance")++ # Placeholder implementation+ # In real implementation, use yfinance library+ logger.info(f"Fetching spot price for {symbol} from Yahoo Finance")+ return 100.0 # Placeholder++ def get_risk_free_rate(self, currency: str = "USD", maturity: float = 0.25) -> float:+ """Get treasury rate as risk-free rate"""+ if not self.connection_status:+ raise ConnectionError("Not connected to Yahoo Finance")++ # Placeholder implementation+ return 0.02 # 2% placeholder++ def get_dividend_yield(self, symbol: str) -> float:+ """Get dividend yield from Yahoo Finance"""+ if not self.connection_status:+ raise ConnectionError("Not connected to Yahoo Finance")++ # Placeholder implementation+ return 0.015 # 1.5% placeholder++ def get_volatility(self, symbol: str, maturity: float, strike: float = None) -> float:+ """Calculate historical volatility"""+ if not self.connection_status:+ raise ConnectionError("Not connected to Yahoo Finance")++ # Placeholder implementation+ return 0.25 # 25% placeholder++ def get_yield_curve(self, currency: str, curve_type: str = "government") -> CurveData:+ """Get treasury yield curve"""+ if not self.connection_status:+ raise ConnectionError("Not connected to Yahoo Finance")++ # Placeholder implementation+ curve = CurveData(+ curve_date=datetime.now(),+ curve_type=curve_type,+ currency=currency,+ day_count=DayCountConvention.ACT_365+ )++ # Add sample treasury rates+ treasury_rates = [+ (0.25, 0.020), (0.5, 0.022), (1.0, 0.025), (2.0, 0.028),+ (5.0, 0.032), (10.0, 0.035), (30.0, 0.038)+ ]++ for maturity, rate in treasury_rates:+ curve.add_point(maturity, rate)++ return curve+++class DataCache:+ """Simple caching mechanism for market data"""++ def __init__(self, max_age_seconds: int = 300): # 5 minutes default+ self.cache = {}+ self.max_age = max_age_seconds++ def get(self, key: str) -> Optional[Any]:+ """Get cached data if not expired"""+ if key in self.cache:+ data, timestamp = self.cache[key]+ age = (datetime.now() - timestamp).total_seconds()+ if age <= self.max_age:+ return data+ else:+ del self.cache[key] # Remove expired data+ return None++ def set(self, key: str, data: Any):+ """Cache data with timestamp"""+ self.cache[key] = (data, datetime.now())++ def clear(self):+ """Clear all cached data"""+ self.cache.clear()+++class MarketDataManager:+ """Central manager for market data from multiple providers"""++ def __init__(self, primary_provider: MarketDataProvider = None):+ self.providers = {}+ self.primary_provider = primary_provider or ManualDataProvider()+ self.cache = DataCache()++ # Register default providers+ self.register_provider("manual", ManualDataProvider())+ self.register_provider("yahoo", YahooFinanceProvider())++ def register_provider(self, name: str, provider: MarketDataProvider):+ """Register a market data provider"""+ self.providers[name] = provider++ def set_primary_provider(self, provider_name: str):+ """Set primary data provider"""+ if provider_name not in self.providers:+ raise ValueError(f"Provider {provider_name} not registered")+ self.primary_provider = self.providers[provider_name]++ def get_market_snapshot(self, symbol: str, currency: str = "USD") -> MarketSnapshot:+ """Get complete market snapshot for symbol"""+ cache_key = f"snapshot_{symbol}_{currency}"+ cached_data = self.cache.get(cache_key)++ if cached_data:+ return cached_data++ try:+ snapshot = MarketSnapshot(+ timestamp=datetime.now(),+ spot_price=self.primary_provider.get_spot_price(symbol),+ risk_free_rate=self.primary_provider.get_risk_free_rate(currency),+ dividend_yield=self.primary_provider.get_dividend_yield(symbol)+ )++ self.cache.set(cache_key, snapshot)+ return snapshot++ except Exception as e:+ logger.error(f"Failed to get market snapshot: {e}")+ raise++ def get_spot_price(self, symbol: str, provider: str = None) -> float:+ """Get spot price with fallback providers"""+ provider_obj = self.providers.get(provider, self.primary_provider)++ try:+ return provider_obj.get_spot_price(symbol)+ except Exception as e:+ logger.warning(f"Primary provider failed for {symbol}: {e}")+ # Try fallback providers+ for name, fallback_provider in self.providers.items():+ if fallback_provider != provider_obj:+ try:+ return fallback_provider.get_spot_price(symbol)+ except:+ continue+ raise ValueError(f"No provider could fetch spot price for {symbol}")+++# Create global market data manager instance+market_data_manager = MarketDataManager()++# Export main classes and functions+__all__ = [+ 'DataProvider', 'DataFrequency', 'YieldCurvePoint', 'VolatilitySurfacePoint',+ 'MarketSnapshot', 'CurveData', 'MarketDataProvider', 'ManualDataProvider',+ 'YahooFinanceProvider', 'DataCache', 'MarketDataManager', 'market_data_manager'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/options.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/options.pynew file mode 100644index 000000000..4cbfba61a--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/options.py@@ -0,0 +1,597 @@+"""+Options Valuation Analytics Module+==================================++Comprehensive options pricing and analytics framework implementing binomial models, Black-Scholes-Merton, Greeks calculations, and put-call parity relationships. Supports European, American, and exotic options with full CFA Institute compliance.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Underlying asset spot prices and price series+ - Option contract specifications (strike, expiry, type)+ - Risk-free interest rates and yield curves+ - Dividend yields and payment schedules+ - Implied volatility surfaces and term structures+ - Historical volatility calculations and forecasts+ - Market prices for calibration and validation++OUTPUT:+ - Option fair values and theoretical prices+ - Complete Greek sensitivities (Delta, Gamma, Theta, Vega, Rho)+ - Implied volatility calculations and surfaces+ - Binomial tree price paths and probabilities+ - Put-call parity arbitrage analysis+ - Delta hedging strategies and recommendations++PARAMETERS:+ - spot_price: Current underlying asset price+ - strike_price: Option strike price+ - time_to_expiry: Time to expiration in years+ - risk_free_rate: Risk-free interest rate+ - dividend_yield: Dividend yield - default: 0.0+ - volatility: Volatility for pricing models+ - option_type: Call or Put option type+ - exercise_style: European or American exercise - default: EUROPEAN+ - steps: Number of binomial tree steps - default: 50+ - option_price: Market option price for implied vol+ - hedge_ratio: Delta hedge ratio for hedging+"""++import numpy as np+from typing import Optional, Dict, Tuple, List+from datetime import datetime+from dataclasses import dataclass+from scipy.stats import norm+from scipy.optimize import brentq+import logging++from .core import (+ ContingentClaim, OptionType, ExerciseStyle, UnderlyingType,+ MarketData, PricingResult, PricingEngine, ValidationError,+ ModelValidator, Constants+)++logger = logging.getLogger(__name__)+++@dataclass+class OptionGreeks:+ """Container for option Greeks"""+ delta: float = 0.0 # Price sensitivity+ gamma: float = 0.0 # Delta sensitivity+ theta: float = 0.0 # Time decay+ vega: float = 0.0 # Volatility sensitivity+ rho: float = 0.0 # Interest rate sensitivity++ # Second-order Greeks+ vanna: float = 0.0 # Delta sensitivity to volatility+ volga: float = 0.0 # Vega sensitivity to volatility+ charm: float = 0.0 # Delta decay over time+ vomma: float = 0.0 # Vega convexity+++@dataclass+class BinomialNode:+ """Single node in binomial tree"""+ time_step: int+ stock_price: float+ option_value: float+ probability_up: float = 0.0+ probability_down: float = 0.0+++class VanillaOption(ContingentClaim):+ """Standard European/American call and put options"""++ def __init__(self,+ option_type: OptionType,+ underlying_type: UnderlyingType,+ expiry_date: datetime,+ strike_price: float,+ exercise_style: ExerciseStyle = ExerciseStyle.EUROPEAN,+ notional: float = 1.0):++ super().__init__(option_type, underlying_type, expiry_date,+ strike_price, exercise_style, notional)++ def calculate_payoff(self, spot_price: float) -> float:+ """Calculate option payoff at expiration"""+ if self.option_type == OptionType.CALL:+ return max(0, spot_price - self.strike_price) * self.notional+ else: # PUT+ return max(0, self.strike_price - spot_price) * self.notional++ def fair_value(self, market_data: MarketData) -> PricingResult:+ """Calculate fair value using appropriate model"""+ if self.exercise_style == ExerciseStyle.EUROPEAN:+ return self._black_scholes_price(market_data)+ else: # American options+ return self._binomial_price(market_data, steps=100)++ def _black_scholes_price(self, market_data: MarketData) -> PricingResult:+ """Black-Scholes-Merton pricing for European options"""+ S = market_data.spot_price+ K = self.strike_price+ T = self.time_to_expiry()+ r = market_data.risk_free_rate+ q = market_data.dividend_yield+ sigma = market_data.volatility++ if T <= 0:+ return PricingResult(fair_value=self.calculate_payoff(S))++ # Calculate d1 and d2+ d1 = (np.log(S / K) + (r - q + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))+ d2 = d1 - sigma * np.sqrt(T)++ # Calculate option price+ if self.option_type == OptionType.CALL:+ price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)+ else: # PUT+ price = K * np.exp(-r * T) * norm.cdf(-d2) - S * np.exp(-q * T) * norm.cdf(-d1)++ price *= self.notional+ intrinsic = self.intrinsic_value(S)++ return PricingResult(+ fair_value=price,+ intrinsic_value=intrinsic,+ time_value=price - intrinsic,+ calculation_details={+ "model": "Black-Scholes-Merton",+ "d1": d1,+ "d2": d2,+ "N_d1": norm.cdf(d1) if self.option_type == OptionType.CALL else norm.cdf(-d1),+ "N_d2": norm.cdf(d2) if self.option_type == OptionType.CALL else norm.cdf(-d2)+ }+ )++ def _binomial_price(self, market_data: MarketData, steps: int = 50) -> PricingResult:+ """Binomial tree pricing for American options"""+ engine = BinomialPricingEngine(steps)+ return engine.price(self, market_data)+++class OnePeriodBinomialModel:+ """One-period binomial option pricing model"""++ def __init__(self, up_factor: float, down_factor: float, risk_free_rate: float, time_period: float):+ self.u = up_factor+ self.d = down_factor+ self.r = risk_free_rate+ self.dt = time_period++ # Calculate risk-neutral probabilities+ self.risk_neutral_prob_up = (np.exp(self.r * self.dt) - self.d) / (self.u - self.d)+ self.risk_neutral_prob_down = 1 - self.risk_neutral_prob_up++ # Validate probabilities+ if not (0 <= self.risk_neutral_prob_up <= 1):+ raise ValidationError(f"Invalid risk-neutral probability: {self.risk_neutral_prob_up}")++ def price_option(self, spot_price: float, strike_price: float, option_type: OptionType) -> Dict:+ """Price option using one-period model"""+ # Calculate stock prices at expiration+ stock_up = spot_price * self.u+ stock_down = spot_price * self.d++ # Calculate option payoffs+ if option_type == OptionType.CALL:+ payoff_up = max(0, stock_up - strike_price)+ payoff_down = max(0, stock_down - strike_price)+ else: # PUT+ payoff_up = max(0, strike_price - stock_up)+ payoff_down = max(0, strike_price - stock_down)++ # Calculate option price using risk-neutral valuation+ expected_payoff = (self.risk_neutral_prob_up * payoff_up ++ self.risk_neutral_prob_down * payoff_down)+ option_price = expected_payoff * np.exp(-self.r * self.dt)++ return {+ "option_price": option_price,+ "stock_up": stock_up,+ "stock_down": stock_down,+ "payoff_up": payoff_up,+ "payoff_down": payoff_down,+ "risk_neutral_prob_up": self.risk_neutral_prob_up,+ "risk_neutral_prob_down": self.risk_neutral_prob_down+ }+++class TwoPeriodBinomialModel:+ """Two-period binomial option pricing model"""++ def __init__(self, up_factor: float, down_factor: float, risk_free_rate: float, time_per_period: float):+ self.u = up_factor+ self.d = down_factor+ self.r = risk_free_rate+ self.dt = time_per_period++ # Risk-neutral probabilities+ self.q = (np.exp(self.r * self.dt) - self.d) / (self.u - self.d)++ if not (0 <= self.q <= 1):+ raise ValidationError(f"Invalid risk-neutral probability: {self.q}")++ def price_option(self, spot_price: float, strike_price: float, option_type: OptionType) -> Dict:+ """Price option using two-period model"""+ # Build stock price tree+ S_uu = spot_price * self.u * self.u+ S_ud = spot_price * self.u * self.d+ S_dd = spot_price * self.d * self.d++ # Calculate payoffs at expiration+ if option_type == OptionType.CALL:+ payoff_uu = max(0, S_uu - strike_price)+ payoff_ud = max(0, S_ud - strike_price)+ payoff_dd = max(0, S_dd - strike_price)+ else: # PUT+ payoff_uu = max(0, strike_price - S_uu)+ payoff_ud = max(0, strike_price - S_ud)+ payoff_dd = max(0, strike_price - S_dd)++ # Work backwards through tree+ # Period 1 values+ S_u = spot_price * self.u+ S_d = spot_price * self.d++ V_u = (self.q * payoff_uu + (1 - self.q) * payoff_ud) * np.exp(-self.r * self.dt)+ V_d = (self.q * payoff_ud + (1 - self.q) * payoff_dd) * np.exp(-self.r * self.dt)++ # Period 0 value (today)+ option_price = (self.q * V_u + (1 - self.q) * V_d) * np.exp(-self.r * self.dt)++ return {+ "option_price": option_price,+ "tree_values": {+ "S_0": spot_price, "S_u": S_u, "S_d": S_d,+ "S_uu": S_uu, "S_ud": S_ud, "S_dd": S_dd,+ "V_0": option_price, "V_u": V_u, "V_d": V_d,+ "payoff_uu": payoff_uu, "payoff_ud": payoff_ud, "payoff_dd": payoff_dd+ },+ "risk_neutral_prob": self.q+ }+++class BinomialPricingEngine(PricingEngine):+ """Multi-period binomial tree pricing engine"""++ def __init__(self, steps: int = 50):+ self.steps = steps++ def price(self, instrument: VanillaOption, market_data: MarketData) -> PricingResult:+ """Price option using binomial tree"""+ if not self.validate_inputs(instrument, market_data):+ raise ValidationError("Invalid inputs for binomial pricing")++ S = market_data.spot_price+ K = instrument.strike_price+ T = instrument.time_to_expiry()+ r = market_data.risk_free_rate+ q = market_data.dividend_yield+ sigma = market_data.volatility++ if T <= 0:+ return PricingResult(fair_value=instrument.calculate_payoff(S))++ # Calculate tree parameters+ dt = T / self.steps+ u = np.exp(sigma * np.sqrt(dt))+ d = 1 / u+ prob_up = (np.exp((r - q) * dt) - d) / (u - d)++ # Build stock price tree+ stock_tree = np.zeros((self.steps + 1, self.steps + 1))+ option_tree = np.zeros((self.steps + 1, self.steps + 1))++ # Initialize stock prices at expiration+ for j in range(self.steps + 1):+ stock_tree[self.steps, j] = S * (u ** (self.steps - j)) * (d ** j)++ # Calculate option values at expiration+ for j in range(self.steps + 1):+ option_tree[self.steps, j] = instrument.calculate_payoff(stock_tree[self.steps, j])++ # Work backwards through tree+ for i in range(self.steps - 1, -1, -1):+ for j in range(i + 1):+ stock_tree[i, j] = S * (u ** (i - j)) * (d ** j)++ # European value+ european_value = (prob_up * option_tree[i + 1, j] ++ (1 - prob_up) * option_tree[i + 1, j + 1]) * np.exp(-r * dt)++ # American exercise value+ if instrument.exercise_style == ExerciseStyle.AMERICAN:+ exercise_value = instrument.calculate_payoff(stock_tree[i, j])+ option_tree[i, j] = max(european_value, exercise_value)+ else:+ option_tree[i, j] = european_value++ fair_value = option_tree[0, 0] * instrument.notional+ intrinsic = instrument.intrinsic_value(S)++ return PricingResult(+ fair_value=fair_value,+ intrinsic_value=intrinsic,+ time_value=fair_value - intrinsic,+ calculation_details={+ "model": "Binomial Tree",+ "steps": self.steps,+ "u": u,+ "d": d,+ "prob_up": prob_up,+ "dt": dt+ }+ )++ def validate_inputs(self, instrument: VanillaOption, market_data: MarketData) -> bool:+ """Validate inputs for binomial pricing"""+ try:+ ModelValidator.validate_positive(market_data.spot_price, "spot_price")+ ModelValidator.validate_positive(instrument.strike_price, "strike_price")+ ModelValidator.validate_volatility(market_data.volatility)+ ModelValidator.validate_rate(market_data.risk_free_rate, "risk_free_rate")+ return True+ except ValidationError:+ return False+++class BlackScholesPricingEngine(PricingEngine):+ """Black-Scholes-Merton pricing engine with Greeks"""++ def price(self, instrument: VanillaOption, market_data: MarketData) -> PricingResult:+ """Price European option using Black-Scholes-Merton"""+ if not self.validate_inputs(instrument, market_data):+ raise ValidationError("Invalid inputs for Black-Scholes pricing")++ if instrument.exercise_style != ExerciseStyle.EUROPEAN:+ raise ValueError("Black-Scholes only valid for European options")++ result = instrument._black_scholes_price(market_data)++ # Calculate Greeks+ greeks = self.calculate_greeks(instrument, market_data)+ result.greeks = greeks.__dict__++ return result++ def calculate_greeks(self, instrument: VanillaOption, market_data: MarketData) -> OptionGreeks:+ """Calculate all option Greeks"""+ S = market_data.spot_price+ K = instrument.strike_price+ T = instrument.time_to_expiry()+ r = market_data.risk_free_rate+ q = market_data.dividend_yield+ sigma = market_data.volatility++ if T <= 0:+ return OptionGreeks()++ # Calculate d1 and d2+ d1 = (np.log(S / K) + (r - q + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))+ d2 = d1 - sigma * np.sqrt(T)++ # Standard normal PDF and CDF+ n_d1 = norm.pdf(d1)+ N_d1 = norm.cdf(d1)+ N_d2 = norm.cdf(d2)++ greeks = OptionGreeks()++ # First-order Greeks+ if instrument.option_type == OptionType.CALL:+ greeks.delta = np.exp(-q * T) * N_d1+ greeks.theta = (-S * n_d1 * sigma * np.exp(-q * T) / (2 * np.sqrt(T))+ - r * K * np.exp(-r * T) * N_d2+ + q * S * np.exp(-q * T) * N_d1) / 365+ greeks.rho = K * T * np.exp(-r * T) * N_d2 / 100+ else: # PUT+ greeks.delta = -np.exp(-q * T) * norm.cdf(-d1)+ greeks.theta = (-S * n_d1 * sigma * np.exp(-q * T) / (2 * np.sqrt(T))+ + r * K * np.exp(-r * T) * norm.cdf(-d2)+ - q * S * np.exp(-q * T) * norm.cdf(-d1)) / 365+ greeks.rho = -K * T * np.exp(-r * T) * norm.cdf(-d2) / 100++ # Common Greeks+ greeks.gamma = n_d1 * np.exp(-q * T) / (S * sigma * np.sqrt(T))+ greeks.vega = S * n_d1 * np.sqrt(T) * np.exp(-q * T) / 100++ # Second-order Greeks+ greeks.vanna = -greeks.vega * d2 / sigma+ greeks.volga = greeks.vega * d1 * d2 / sigma+ greeks.charm = (q * np.exp(-q * T) * norm.cdf(d1 if instrument.option_type == OptionType.CALL else -d1)+ - np.exp(-q * T) * n_d1 * (2 * (r - q) * T - d2 * sigma * np.sqrt(T)) / (+ 2 * T * sigma * np.sqrt(T))) / 365++ return greeks++ def validate_inputs(self, instrument: VanillaOption, market_data: MarketData) -> bool:+ """Validate inputs for Black-Scholes pricing"""+ try:+ ModelValidator.validate_positive(market_data.spot_price, "spot_price")+ ModelValidator.validate_positive(instrument.strike_price, "strike_price")+ ModelValidator.validate_volatility(market_data.volatility)+ ModelValidator.validate_rate(market_data.risk_free_rate, "risk_free_rate")+ ModelValidator.validate_non_negative(market_data.dividend_yield, "dividend_yield")++ if instrument.time_to_expiry() < 0:+ return False++ return True+ except ValidationError:+ return False+++class BlackModelPricingEngine(PricingEngine):+ """Black model for options on futures and forwards"""++ def price(self, instrument: VanillaOption, market_data: MarketData) -> PricingResult:+ """Price option on futures using Black model"""+ if not self.validate_inputs(instrument, market_data):+ raise ValidationError("Invalid inputs for Black model pricing")++ F = market_data.forward_price or market_data.spot_price # Forward/Futures price+ K = instrument.strike_price+ T = instrument.time_to_expiry()+ r = market_data.risk_free_rate+ sigma = market_data.volatility++ if T <= 0:+ return PricingResult(fair_value=instrument.calculate_payoff(F))++ # Black model d1 and d2+ d1 = (np.log(F / K) + 0.5 * sigma ** 2 * T) / (sigma * np.sqrt(T))+ d2 = d1 - sigma * np.sqrt(T)++ # Calculate option price+ if instrument.option_type == OptionType.CALL:+ price = np.exp(-r * T) * (F * norm.cdf(d1) - K * norm.cdf(d2))+ else: # PUT+ price = np.exp(-r * T) * (K * norm.cdf(-d2) - F * norm.cdf(-d1))++ price *= instrument.notional++ return PricingResult(+ fair_value=price,+ calculation_details={+ "model": "Black Model",+ "forward_price": F,+ "d1": d1,+ "d2": d2+ }+ )++ def validate_inputs(self, instrument: VanillaOption, market_data: MarketData) -> bool:+ """Validate inputs for Black model"""+ try:+ forward_price = market_data.forward_price or market_data.spot_price+ ModelValidator.validate_positive(forward_price, "forward_price")+ ModelValidator.validate_positive(instrument.strike_price, "strike_price")+ ModelValidator.validate_volatility(market_data.volatility)+ ModelValidator.validate_rate(market_data.risk_free_rate, "risk_free_rate")+ return True+ except ValidationError:+ return False+++class PutCallParity:+ """Put-call parity relationships"""++ @staticmethod+ def european_parity(call_price: float, put_price: float, spot_price: float,+ strike_price: float, risk_free_rate: float, time_to_expiry: float,+ dividend_yield: float = 0.0) -> Dict[str, float]:+ """Verify European put-call parity: C + K*e^(-rT) = P + S*e^(-qT)"""++ pv_strike = strike_price * np.exp(-risk_free_rate * time_to_expiry)+ pv_spot = spot_price * np.exp(-dividend_yield * time_to_expiry)++ left_side = call_price + pv_strike+ right_side = put_price + pv_spot++ arbitrage_profit = abs(left_side - right_side)++ return {+ "call_synthetic": put_price + pv_spot - pv_strike,+ "put_synthetic": call_price + pv_strike - pv_spot,+ "arbitrage_profit": arbitrage_profit,+ "parity_holds": arbitrage_profit < Constants.EPSILON+ }++ @staticmethod+ def forward_parity(call_price: float, put_price: float, forward_price: float,+ strike_price: float, risk_free_rate: float, time_to_expiry: float) -> Dict[str, float]:+ """Put-call forward parity: C - P = (F - K) * e^(-rT)"""++ pv_diff = (forward_price - strike_price) * np.exp(-risk_free_rate * time_to_expiry)+ actual_diff = call_price - put_price++ arbitrage_profit = abs(actual_diff - pv_diff)++ return {+ "theoretical_diff": pv_diff,+ "actual_diff": actual_diff,+ "arbitrage_profit": arbitrage_profit,+ "parity_holds": arbitrage_profit < Constants.EPSILON+ }+++class ImpliedVolatilityCalculator:+ """Calculate implied volatility from option prices"""++ @staticmethod+ def calculate_iv(option_price: float, spot_price: float, strike_price: float,+ time_to_expiry: float, risk_free_rate: float,+ option_type: OptionType, dividend_yield: float = 0.0) -> float:+ """Calculate implied volatility using Brent's method"""++ def objective_function(vol):+ """Objective function for root finding"""+ market_data = MarketData(+ spot_price=spot_price,+ risk_free_rate=risk_free_rate,+ dividend_yield=dividend_yield,+ volatility=vol,+ time_to_expiry=time_to_expiry+ )++ option = VanillaOption(+ option_type=option_type,+ underlying_type=UnderlyingType.EQUITY,+ expiry_date=datetime.now(),+ strike_price=strike_price+ )++ theoretical_price = option._black_scholes_price(market_data).fair_value+ return theoretical_price - option_price++ try:+ # Brent's method for root finding+ implied_vol = brentq(objective_function, 0.001, 5.0, xtol=1e-6)+ return implied_vol+ except ValueError:+ logger.warning("Could not calculate implied volatility")+ return np.nan+++class DeltaHedging:+ """Delta hedging implementation"""++ def __init__(self, option: VanillaOption, hedge_ratio: float = None):+ self.option = option+ self.hedge_ratio = hedge_ratio+ self.position_delta = 0.0+ self.hedge_position = 0.0++ def calculate_hedge_ratio(self, market_data: MarketData) -> float:+ """Calculate delta hedge ratio"""+ engine = BlackScholesPricingEngine()+ greeks = engine.calculate_greeks(self.option, market_data)+ return -greeks.delta # Opposite sign for hedging++ def rebalance_hedge(self, market_data: MarketData, option_position: float = 1.0) -> Dict:+ """Rebalance delta hedge"""+ new_hedge_ratio = self.calculate_hedge_ratio(market_data)+ new_hedge_position = new_hedge_ratio * option_position++ hedge_adjustment = new_hedge_position - self.hedge_position++ self.hedge_ratio = new_hedge_ratio+ self.hedge_position = new_hedge_position++ return {+ "new_hedge_ratio": new_hedge_ratio,+ "new_hedge_position": new_hedge_position,+ "hedge_adjustment": hedge_adjustment,+ "cost_of_adjustment": abs(hedge_adjustment) * market_data.spot_price+ }+++# Export main classes+__all__ = [+ 'OptionGreeks', 'BinomialNode', 'VanillaOption', 'OnePeriodBinomialModel',+ 'TwoPeriodBinomialModel', 'BinomialPricingEngine', 'BlackScholesPricingEngine',+ 'BlackModelPricingEngine', 'PutCallParity', 'ImpliedVolatilityCalculator',+ 'DeltaHedging'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/utils.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/utils.pynew file mode 100644index 000000000..ea78494ea--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/derivatives/utils.py@@ -0,0 +1,731 @@++Derivatives Utils Module+=================================++Fixed income utility functions++===== DATA SOURCES REQUIRED =====+INPUT:+ - Underlying asset price data and market information+ - Option chain data with strikes, expirations, and premiums+ - Interest rate curves and volatility surfaces+ - Market quotes and bid-ask spreads+ - Counterparty information and collateral data++OUTPUT:+ - Derivatives pricing models and Greeks calculations+ - Portfolio risk metrics and exposure analysis+ - Arbitrage opportunities and trading signals+ - Scenario analysis and stress test results+ - Hedging effectiveness and optimization recommendations++PARAMETERS:+ - risk_free_rate: Risk-free rate for option pricing (default: 0.02)+ - volatility_method: Volatility estimation method (default: 'historical')+ - dividend_yield: Dividend yield for underlying assets (default: 0.0)+ - time_steps: Number of time steps for simulation (default: 100)+ - confidence_level: Confidence level for risk metrics (default: 0.95)+++import numpy as np+import pandas as pd+from typing import List, Tuple, Optional, Callable, Union, Dict, Any+from datetime import datetime, date, timedelta+from scipy import optimize, interpolate, stats+from scipy.special import erf, erfc+import calendar+import logging+from enum import Enum+from dataclasses import dataclass++from .core import DayCountConvention, ValidationError, ModelValidator++logger = logging.getLogger(__name__)+++class InterpolationMethod(Enum):+ """Interpolation methods for yield curves and surfaces"""+ LINEAR = "linear"+ CUBIC_SPLINE = "cubic"+ NATURAL_SPLINE = "natural"+ HERMITE = "hermite"+ AKIMA = "akima"+++class OptimizationMethod(Enum):+ """Optimization methods for numerical procedures"""+ NEWTON_RAPHSON = "newton_raphson"+ BISECTION = "bisection"+ BRENT = "brent"+ SECANT = "secant"+ LEVENBERG_MARQUARDT = "lm"+++@dataclass+class Holiday:+ """Holiday definition for business day calculations"""+ name: str+ date: datetime+ country: str = "US"+++class BusinessDayCalculator:+ """Business day calculations with holiday support"""++ def __init__(self, country: str = "US"):+ self.country = country+ self.holidays = self._load_holidays()++ def _load_holidays(self) -> List[Holiday]:+ """Load holidays for specified country"""+ # US Federal Holidays (simplified)+ current_year = datetime.now().year+ holidays = []++ for year in range(current_year - 1, current_year + 5):+ # New Year's Day+ holidays.append(Holiday("New Year's Day", datetime(year, 1, 1)))++ # Independence Day+ holidays.append(Holiday("Independence Day", datetime(year, 7, 4)))++ # Christmas Day+ holidays.append(Holiday("Christmas Day", datetime(year, 12, 25)))++ # Martin Luther King Jr. Day (3rd Monday in January)+ jan_1 = datetime(year, 1, 1)+ days_to_monday = (7 - jan_1.weekday()) % 7+ first_monday = jan_1 + timedelta(days=days_to_monday)+ mlk_day = first_monday + timedelta(days=14) # 3rd Monday+ holidays.append(Holiday("MLK Day", mlk_day))++ # Presidents Day (3rd Monday in February)+ feb_1 = datetime(year, 2, 1)+ days_to_monday = (7 - feb_1.weekday()) % 7+ first_monday = feb_1 + timedelta(days=days_to_monday)+ presidents_day = first_monday + timedelta(days=14)+ holidays.append(Holiday("Presidents Day", presidents_day))++ # Labor Day (1st Monday in September)+ sep_1 = datetime(year, 9, 1)+ days_to_monday = (7 - sep_1.weekday()) % 7+ labor_day = sep_1 + timedelta(days=days_to_monday)+ holidays.append(Holiday("Labor Day", labor_day))++ # Thanksgiving (4th Thursday in November)+ nov_1 = datetime(year, 11, 1)+ days_to_thursday = (3 - nov_1.weekday()) % 7+ first_thursday = nov_1 + timedelta(days=days_to_thursday)+ thanksgiving = first_thursday + timedelta(days=21) # 4th Thursday+ holidays.append(Holiday("Thanksgiving", thanksgiving))++ return holidays++ def is_business_day(self, date_input: Union[datetime, date]) -> bool:+ """Check if date is a business day"""+ if isinstance(date_input, date):+ date_input = datetime.combine(date_input, datetime.min.time())++ # Check if weekend+ if date_input.weekday() >= 5: # Saturday = 5, Sunday = 6+ return False++ # Check if holiday+ for holiday in self.holidays:+ if (date_input.date() == holiday.date.date() and+ holiday.country == self.country):+ return False++ return True++ def add_business_days(self, start_date: Union[datetime, date],+ days: int) -> datetime:+ """Add business days to a date"""+ if isinstance(start_date, date):+ start_date = datetime.combine(start_date, datetime.min.time())++ current_date = start_date+ days_added = 0++ while days_added < days:+ current_date += timedelta(days=1)+ if self.is_business_day(current_date):+ days_added += 1++ return current_date++ def business_days_between(self, start_date: Union[datetime, date],+ end_date: Union[datetime, date]) -> int:+ """Count business days between two dates"""+ if isinstance(start_date, date):+ start_date = datetime.combine(start_date, datetime.min.time())+ if isinstance(end_date, date):+ end_date = datetime.combine(end_date, datetime.min.time())++ if start_date >= end_date:+ return 0++ business_days = 0+ current_date = start_date++ while current_date < end_date:+ current_date += timedelta(days=1)+ if self.is_business_day(current_date):+ business_days += 1++ return business_days+++class MathUtils:+ """Mathematical utility functions for derivatives pricing"""++ @staticmethod+ def normal_cdf(x: float) -> float:+ """Cumulative distribution function of standard normal"""+ return 0.5 * (1 + erf(x / np.sqrt(2)))++ @staticmethod+ def normal_pdf(x: float) -> float:+ """Probability density function of standard normal"""+ return np.exp(-0.5 * x ** 2) / np.sqrt(2 * np.pi)++ @staticmethod+ def inverse_normal_cdf(p: float) -> float:+ """Inverse cumulative distribution function (quantile)"""+ if not 0 < p < 1:+ raise ValueError("Probability must be between 0 and 1")+ return stats.norm.ppf(p)++ @staticmethod+ def bivariate_normal_cdf(x: float, y: float, rho: float) -> float:+ """Bivariate normal cumulative distribution function"""+ return stats.multivariate_normal.cdf([x, y], cov=[[1, rho], [rho, 1]])++ @staticmethod+ def black_scholes_call_delta(S: float, K: float, T: float, r: float,+ sigma: float, q: float = 0) -> float:+ """Black-Scholes call delta (analytical)"""+ if T <= 0:+ return 1.0 if S > K else 0.0++ d1 = (np.log(S / K) + (r - q + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))+ return np.exp(-q * T) * MathUtils.normal_cdf(d1)++ @staticmethod+ def black_scholes_gamma(S: float, K: float, T: float, r: float,+ sigma: float, q: float = 0) -> float:+ """Black-Scholes gamma (analytical)"""+ if T <= 0:+ return 0.0++ d1 = (np.log(S / K) + (r - q + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))+ return (np.exp(-q * T) * MathUtils.normal_pdf(d1)) / (S * sigma * np.sqrt(T))++ @staticmethod+ def compound_interest(principal: float, rate: float, time: float,+ frequency: int = 1) -> float:+ """Calculate compound interest"""+ return principal * (1 + rate / frequency) ** (frequency * time)++ @staticmethod+ def continuous_compounding(principal: float, rate: float, time: float) -> float:+ """Calculate continuous compounding"""+ return principal * np.exp(rate * time)++ @staticmethod+ def present_value(future_value: float, rate: float, time: float) -> float:+ """Calculate present value with continuous compounding"""+ return future_value * np.exp(-rate * time)++ @staticmethod+ def annuity_pv(payment: float, rate: float, periods: int) -> float:+ """Present value of ordinary annuity"""+ if rate == 0:+ return payment * periods+ return payment * (1 - (1 + rate) ** -periods) / rate++ @staticmethod+ def perpetuity_pv(payment: float, rate: float) -> float:+ """Present value of perpetuity"""+ if rate <= 0:+ raise ValueError("Rate must be positive for perpetuity")+ return payment / rate+++class InterpolationEngine:+ """Advanced interpolation methods for financial data"""++ @staticmethod+ def linear_interpolation(x_points: np.ndarray, y_points: np.ndarray,+ x_new: Union[float, np.ndarray]) -> Union[float, np.ndarray]:+ """Linear interpolation"""+ if len(x_points) != len(y_points):+ raise ValueError("x_points and y_points must have same length")++ return np.interp(x_new, x_points, y_points)++ @staticmethod+ def cubic_spline_interpolation(x_points: np.ndarray, y_points: np.ndarray,+ x_new: Union[float, np.ndarray]) -> Union[float, np.ndarray]:+ """Cubic spline interpolation"""+ if len(x_points) < 4:+ return InterpolationEngine.linear_interpolation(x_points, y_points, x_new)++ spline = interpolate.CubicSpline(x_points, y_points)+ return spline(x_new)++ @staticmethod+ def natural_spline_interpolation(x_points: np.ndarray, y_points: np.ndarray,+ x_new: Union[float, np.ndarray]) -> Union[float, np.ndarray]:+ """Natural cubic spline interpolation"""+ if len(x_points) < 4:+ return InterpolationEngine.linear_interpolation(x_points, y_points, x_new)++ spline = interpolate.CubicSpline(x_points, y_points, bc_type='natural')+ return spline(x_new)++ @staticmethod+ def akima_interpolation(x_points: np.ndarray, y_points: np.ndarray,+ x_new: Union[float, np.ndarray]) -> Union[float, np.ndarray]:+ """Akima interpolation (good for yield curves)"""+ if len(x_points) < 5:+ return InterpolationEngine.cubic_spline_interpolation(x_points, y_points, x_new)++ akima = interpolate.Akima1DInterpolator(x_points, y_points)+ return akima(x_new)++ @staticmethod+ def interpolate_yield_curve(maturities: np.ndarray, rates: np.ndarray,+ target_maturity: float,+ method: InterpolationMethod = InterpolationMethod.CUBIC_SPLINE) -> float:+ """Interpolate yield curve for specific maturity"""+ if method == InterpolationMethod.LINEAR:+ return InterpolationEngine.linear_interpolation(maturities, rates, target_maturity)+ elif method == InterpolationMethod.CUBIC_SPLINE:+ return InterpolationEngine.cubic_spline_interpolation(maturities, rates, target_maturity)+ elif method == InterpolationMethod.NATURAL_SPLINE:+ return InterpolationEngine.natural_spline_interpolation(maturities, rates, target_maturity)+ elif method == InterpolationMethod.AKIMA:+ return InterpolationEngine.akima_interpolation(maturities, rates, target_maturity)+ else:+ return InterpolationEngine.linear_interpolation(maturities, rates, target_maturity)+++class OptimizationSolver:+ """Numerical optimization methods for derivatives pricing"""++ @staticmethod+ def newton_raphson(func: Callable, derivative: Callable, initial_guess: float,+ tolerance: float = 1e-8, max_iterations: int = 100) -> Dict[str, Any]:+ """Newton-Raphson root finding method"""+ x = initial_guess++ for i in range(max_iterations):+ try:+ f_x = func(x)+ f_prime_x = derivative(x)++ if abs(f_prime_x) < tolerance:+ return {"success": False, "message": "Derivative too small", "iterations": i}++ x_new = x - f_x / f_prime_x++ if abs(x_new - x) < tolerance:+ return {+ "success": True,+ "root": x_new,+ "function_value": func(x_new),+ "iterations": i + 1+ }++ x = x_new++ except Exception as e:+ return {"success": False, "message": str(e), "iterations": i}++ return {"success": False, "message": "Max iterations reached", "iterations": max_iterations}++ @staticmethod+ def bisection_method(func: Callable, a: float, b: float,+ tolerance: float = 1e-8, max_iterations: int = 100) -> Dict[str, Any]:+ """Bisection root finding method"""+ if func(a) * func(b) >= 0:+ return {"success": False, "message": "Function must have opposite signs at endpoints"}++ for i in range(max_iterations):+ c = (a + b) / 2+ f_c = func(c)++ if abs(f_c) < tolerance or (b - a) / 2 < tolerance:+ return {+ "success": True,+ "root": c,+ "function_value": f_c,+ "iterations": i + 1+ }++ if func(a) * f_c < 0:+ b = c+ else:+ a = c++ return {"success": False, "message": "Max iterations reached", "iterations": max_iterations}++ @staticmethod+ def brent_method(func: Callable, a: float, b: float,+ tolerance: float = 1e-8) -> Dict[str, Any]:+ """Brent's method for root finding (most robust)"""+ try:+ result = optimize.brentq(func, a, b, xtol=tolerance, full_output=True)+ root, result_info = result++ return {+ "success": True,+ "root": root,+ "function_value": func(root),+ "iterations": result_info.iterations,+ "function_calls": result_info.function_calls+ }+ except Exception as e:+ return {"success": False, "message": str(e)}++ @staticmethod+ def golden_section_search(func: Callable, a: float, b: float,+ tolerance: float = 1e-8, maximize: bool = False) -> Dict[str, Any]:+ """Golden section search for optimization"""+ golden_ratio = (1 + np.sqrt(5)) / 2+ resphi = 2 - golden_ratio++ tol = tolerance+ x1 = a + resphi * (b - a)+ x2 = b - resphi * (b - a)+ f1 = func(x1)+ f2 = func(x2)++ if maximize:+ f1, f2 = -f1, -f2++ iterations = 0+ while abs(b - a) > tol:+ iterations += 1+ if f1 < f2:+ b = x2+ x2 = x1+ f2 = f1+ x1 = a + resphi * (b - a)+ f1 = func(x1)+ if maximize:+ f1 = -f1+ else:+ a = x1+ x1 = x2+ f1 = f2+ x2 = b - resphi * (b - a)+ f2 = func(x2)+ if maximize:+ f2 = -f2++ optimal_x = (a + b) / 2+ optimal_value = func(optimal_x)++ return {+ "success": True,+ "optimal_x": optimal_x,+ "optimal_value": optimal_value if not maximize else -optimal_value,+ "iterations": iterations+ }+++class StatisticalUtils:+ """Statistical utility functions"""++ @staticmethod+ def calculate_returns(prices: np.ndarray, method: str = "log") -> np.ndarray:+ """Calculate returns from price series"""+ if len(prices) < 2:+ return np.array([])++ if method == "log":+ return np.diff(np.log(prices))+ elif method == "simple":+ return np.diff(prices) / prices[:-1]+ else:+ raise ValueError("Method must be 'log' or 'simple'")++ @staticmethod+ def rolling_volatility(returns: np.ndarray, window: int,+ annualize: bool = True) -> np.ndarray:+ """Calculate rolling volatility"""+ if len(returns) < window:+ return np.array([])++ rolling_vol = []+ for i in range(window - 1, len(returns)):+ window_returns = returns[i - window + 1:i + 1]+ vol = np.std(window_returns)+ if annualize:+ vol *= np.sqrt(252) # Assuming daily returns+ rolling_vol.append(vol)++ return np.array(rolling_vol)++ @staticmethod+ def ewma_volatility(returns: np.ndarray, lambda_param: float = 0.94,+ annualize: bool = True) -> np.ndarray:+ """Exponentially weighted moving average volatility"""+ if len(returns) == 0:+ return np.array([])++ ewma_var = np.zeros(len(returns))+ ewma_var[0] = returns[0] ** 2++ for i in range(1, len(returns)):+ ewma_var[i] = lambda_param * ewma_var[i - 1] + (1 - lambda_param) * returns[i] ** 2++ ewma_vol = np.sqrt(ewma_var)+ if annualize:+ ewma_vol *= np.sqrt(252)++ return ewma_vol++ @staticmethod+ def garch_volatility(returns: np.ndarray, p: int = 1, q: int = 1) -> Dict[str, Any]:+ """GARCH(p,q) volatility estimation (simplified)"""+ # This is a simplified implementation+ # In practice, use specialized libraries like arch++ n = len(returns)+ if n < max(p, q) + 10:+ return {"success": False, "message": "Insufficient data for GARCH"}++ # Simple GARCH(1,1) implementation+ if p == 1 and q == 1:+ omega = 0.000001 # Long-term variance+ alpha = 0.1 # ARCH parameter+ beta = 0.85 # GARCH parameter++ conditional_var = np.zeros(n)+ conditional_var[0] = np.var(returns)++ for i in range(1, n):+ conditional_var[i] = (omega ++ alpha * returns[i - 1] ** 2 ++ beta * conditional_var[i - 1])++ conditional_vol = np.sqrt(conditional_var)++ return {+ "success": True,+ "conditional_volatility": conditional_vol,+ "parameters": {"omega": omega, "alpha": alpha, "beta": beta}+ }++ return {"success": False, "message": "Only GARCH(1,1) implemented"}++ @staticmethod+ def correlation_matrix(returns_matrix: np.ndarray, method: str = "pearson") -> np.ndarray:+ """Calculate correlation matrix"""+ if method == "pearson":+ return np.corrcoef(returns_matrix, rowvar=False)+ elif method == "spearman":+ return stats.spearmanr(returns_matrix).correlation+ elif method == "kendall":+ # Simplified Kendall's tau for multiple variables+ n_vars = returns_matrix.shape[1]+ corr_matrix = np.eye(n_vars)+ for i in range(n_vars):+ for j in range(i + 1, n_vars):+ tau, _ = stats.kendalltau(returns_matrix[:, i], returns_matrix[:, j])+ corr_matrix[i, j] = tau+ corr_matrix[j, i] = tau+ return corr_matrix+ else:+ raise ValueError("Method must be 'pearson', 'spearman', or 'kendall'")++ @staticmethod+ def jarque_bera_test(data: np.ndarray) -> Dict[str, float]:+ """Jarque-Bera test for normality"""+ n = len(data)+ if n < 4:+ return {"statistic": np.nan, "p_value": np.nan}++ # Calculate skewness and kurtosis+ mean_data = np.mean(data)+ std_data = np.std(data, ddof=1)++ skewness = np.mean(((data - mean_data) / std_data) ** 3)+ kurtosis = np.mean(((data - mean_data) / std_data) ** 4)++ # Jarque-Bera statistic+ jb_statistic = n * (skewness ** 2 / 6 + (kurtosis - 3) ** 2 / 24)++ # p-value (chi-squared distribution with 2 degrees of freedom)+ p_value = 1 - stats.chi2.cdf(jb_statistic, 2)++ return {+ "statistic": jb_statistic,+ "p_value": p_value,+ "skewness": skewness,+ "kurtosis": kurtosis,+ "is_normal": p_value > 0.05 # 5% significance level+ }+++class DateUtils:+ """Date utility functions for financial calculations"""++ @staticmethod+ def year_fraction(start_date: Union[datetime, date],+ end_date: Union[datetime, date],+ day_count: DayCountConvention = DayCountConvention.ACT_365) -> float:+ """Calculate year fraction between dates"""+ if isinstance(start_date, date):+ start_date = datetime.combine(start_date, datetime.min.time())+ if isinstance(end_date, date):+ end_date = datetime.combine(end_date, datetime.min.time())++ if end_date <= start_date:+ return 0.0++ if day_count == DayCountConvention.ACT_365:+ return (end_date - start_date).days / 365.0+ elif day_count == DayCountConvention.ACT_360:+ return (end_date - start_date).days / 360.0+ elif day_count == DayCountConvention.THIRTY_360:+ return DateUtils._thirty_360_fraction(start_date, end_date)+ elif day_count == DayCountConvention.ACT_ACT:+ return DateUtils._act_act_fraction(start_date, end_date)+ else:+ return (end_date - start_date).days / 365.0++ @staticmethod+ def _thirty_360_fraction(start_date: datetime, end_date: datetime) -> float:+ """30/360 day count calculation"""+ start_day = min(start_date.day, 30)+ end_day = end_date.day++ if start_day == 30 and end_day == 31:+ end_day = 30++ days = (360 * (end_date.year - start_date.year) ++ 30 * (end_date.month - start_date.month) ++ (end_day - start_day))++ return days / 360.0++ @staticmethod+ def _act_act_fraction(start_date: datetime, end_date: datetime) -> float:+ """ACT/ACT day count calculation"""+ total_days = 0+ current_year = start_date.year+ current_date = start_date++ while current_date < end_date:+ year_end = datetime(current_year, 12, 31)+ next_year_start = datetime(current_year + 1, 1, 1)++ if end_date <= year_end:+ # All remaining days in current year+ days_in_year = (end_date - current_date).days+ year_length = 366 if calendar.isleap(current_year) else 365+ total_days += days_in_year / year_length+ break+ else:+ # Days remaining in current year+ days_in_year = (next_year_start - current_date).days+ year_length = 366 if calendar.isleap(current_year) else 365+ total_days += days_in_year / year_length++ current_year += 1+ current_date = next_year_start++ return total_days++ @staticmethod+ def add_tenor(start_date: Union[datetime, date], tenor: str) -> datetime:+ """Add tenor to date (e.g., '3M', '1Y', '6W')"""+ if isinstance(start_date, date):+ start_date = datetime.combine(start_date, datetime.min.time())++ tenor = tenor.upper()++ if tenor.endswith('D'):+ days = int(tenor[:-1])+ return start_date + timedelta(days=days)+ elif tenor.endswith('W'):+ weeks = int(tenor[:-1])+ return start_date + timedelta(weeks=weeks)+ elif tenor.endswith('M'):+ months = int(tenor[:-1])+ new_month = start_date.month + months+ new_year = start_date.year + (new_month - 1) // 12+ new_month = ((new_month - 1) % 12) + 1++ # Handle end-of-month dates+ try:+ return start_date.replace(year=new_year, month=new_month)+ except ValueError:+ # Handle cases like Jan 31 + 1M = Feb 28/29+ last_day = calendar.monthrange(new_year, new_month)[1]+ return start_date.replace(year=new_year, month=new_month, day=last_day)+ elif tenor.endswith('Y'):+ years = int(tenor[:-1])+ try:+ return start_date.replace(year=start_date.year + years)+ except ValueError:+ # Handle leap year edge case (Feb 29)+ return start_date.replace(year=start_date.year + years, month=2, day=28)+ else:+ raise ValueError(f"Invalid tenor format: {tenor}")++ @staticmethod+ def generate_schedule(start_date: Union[datetime, date],+ end_date: Union[datetime, date],+ frequency: str = "3M",+ business_day_convention: str = "modified_following") -> List[datetime]:+ """Generate payment schedule between dates"""+ if isinstance(start_date, date):+ start_date = datetime.combine(start_date, datetime.min.time())+ if isinstance(end_date, date):+ end_date = datetime.combine(end_date, datetime.min.time())++ schedule = []+ current_date = start_date++ bdc = BusinessDayCalculator()++ while current_date < end_date:+ next_date = DateUtils.add_tenor(current_date, frequency)++ if next_date > end_date:+ next_date = end_date++ # Apply business day convention+ if business_day_convention == "following":+ while not bdc.is_business_day(next_date):+ next_date += timedelta(days=1)+ elif business_day_convention == "preceding":+ while not bdc.is_business_day(next_date):+ next_date -= timedelta(days=1)+ elif business_day_convention == "modified_following":+ original_month = next_date.month+ while not bdc.is_business_day(next_date):+ next_date += timedelta(days=1)+ if next_date.month != original_month:+ # Rolled into next month, use preceding instead+ next_date = DateUtils.add_tenor(current_date, frequency)+ while not bdc.is_business_day(next_date):+ next_date -= timedelta(days=1)+ break++ schedule.append(next_date)+ current_date = next_date++ return schedule+++# Export main classes and functions+__all__ = [+ 'InterpolationMethod', 'OptimizationMethod', 'Holiday', 'BusinessDayCalculator',+ 'MathUtils', 'InterpolationEngine', 'OptimizationSolver', 'StatisticalUtils', 'DateUtils'+]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/__init__.pynew file mode 100644index 000000000..1eb2a15c2--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/__init__.py@@ -0,0 +1,194 @@++Economic Init Module+=============================++ Init analysis and calculation tools++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++from .core import (+ EconomicsBase,+ DataValidator,+ EconomicsError,+ ValidationError,+ CalculationError,+ DataError+)++from .currency_analysis import (+ CurrencyAnalyzer,+ SpotForwardAnalyzer,+ ArbitrageDetector,+ ParityAnalyzer,+ CarryTradeAnalyzer+)++from .exchange_calculations import (+ ExchangeCalculator,+ CrossRateCalculator,+ ForwardCalculator+)++from .growth_analysis import (+ GrowthAnalyzer,+ ProductivityAnalyzer,+ ConvergenceAnalyzer,+ DemographicAnalyzer+)++from .market_cycles import (+ BusinessCycleAnalyzer,+ MarketStructureAnalyzer,+ CreditCycleAnalyzer+)++from .policy_analysis import (+ FiscalPolicyAnalyzer,+ MonetaryPolicyAnalyzer,+ CentralBankAnalyzer+)++from .trade_geopolitics import (+ TradeAnalyzer,+ GeopoliticalRiskAnalyzer,+ TradingBlocAnalyzer+)++from .capital_flows import (+ CapitalFlowAnalyzer,+ FXMarketAnalyzer,+ ExchangeRegimeAnalyzer+)++from .data_handler import (+ DataHandler,+ DataProvider,+ ManualDataInput+)++from .analytics_engine import (+ StatisticalAnalyzer,+ ForecastingEngine,+ ScenarioAnalyzer+)++from .reporting import (+ ReportGenerator,+ VisualizationEngine,+ ExportManager+)++from .config import (+ EconomicsConfig,+ DataSources,+ CalculationPrecision+)++__version__ = "1.0.0"+__author__ = "Fincept Corporation"+__email__ = "[email protected]"++# Module metadata+__all__ = [+ # Core components+ 'EconomicsBase', 'DataValidator', 'EconomicsError', 'ValidationError',+ 'CalculationError', 'DataError',++ # Analysis modules+ 'CurrencyAnalyzer', 'SpotForwardAnalyzer', 'ArbitrageDetector',+ 'ParityAnalyzer', 'CarryTradeAnalyzer', 'ExchangeCalculator',+ 'CrossRateCalculator', 'ForwardCalculator', 'GrowthAnalyzer',+ 'ProductivityAnalyzer', 'ConvergenceAnalyzer', 'DemographicAnalyzer',+ 'BusinessCycleAnalyzer', 'MarketStructureAnalyzer', 'CreditCycleAnalyzer',+ 'FiscalPolicyAnalyzer', 'MonetaryPolicyAnalyzer', 'CentralBankAnalyzer',+ 'TradeAnalyzer', 'GeopoliticalRiskAnalyzer', 'TradingBlocAnalyzer',+ 'CapitalFlowAnalyzer', 'FXMarketAnalyzer', 'ExchangeRegimeAnalyzer',++ # Infrastructure+ 'DataHandler', 'DataProvider', 'ManualDataInput',+ 'StatisticalAnalyzer', 'ForecastingEngine', 'ScenarioAnalyzer',+ 'ReportGenerator', 'VisualizationEngine', 'ExportManager',+ 'EconomicsConfig', 'DataSources', 'CalculationPrecision'+]+++# Quick access functions for common operations+def analyze_currency_arbitrage(currency_data, base_currency='USD'):+ """Quick triangular arbitrage analysis"""+ detector = ArbitrageDetector()+ return detector.detect_triangular_arbitrage(currency_data, base_currency)+++def calculate_gdp_growth(gdp_data, method='solow'):+ """Quick GDP growth decomposition"""+ analyzer = GrowthAnalyzer()+ return analyzer.decompose_growth(gdp_data, method)+++def assess_policy_impact(policy_data, policy_type='fiscal'):+ """Quick policy impact assessment"""+ if policy_type == 'fiscal':+ analyzer = FiscalPolicyAnalyzer()+ else:+ analyzer = MonetaryPolicyAnalyzer()+ return analyzer.assess_impact(policy_data)+++def detect_business_cycle_phase(economic_indicators):+ """Quick business cycle phase detection"""+ analyzer = BusinessCycleAnalyzer()+ return analyzer.detect_phase(economic_indicators)+++# Module configuration+DEFAULT_CONFIG = {+ 'precision': 8,+ 'base_currency': 'USD',+ 'data_validation': True,+ 'error_tolerance': 1e-6,+ 'default_forecast_periods': 12,+ 'confidence_interval': 0.95+}+++def configure_module(**kwargs):+ """Configure module-wide settings"""+ config = EconomicsConfig()+ for key, value in kwargs.items():+ if hasattr(config, key):+ setattr(config, key, value)+ return config+++# Version information+def get_version_info():+ """Return detailed version information"""+ return {+ 'version': __version__,+ 'author': __author__,+ 'email': __email__,+ 'description': 'CFA-based Economics Analysis Module for FinceptTerminal',+ 'modules': len(__all__),+ 'cfa_compliance': 'Level I & II'+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/analytics_engine.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/analytics_engine.pynew file mode 100644index 000000000..15f0a3a6c--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/analytics_engine.py@@ -0,0 +1,1352 @@+"""+Analytics Engine Module+=======================++Advanced statistical analysis, forecasting, and scenario analysis for economic data.+Provides sophisticated analytical capabilities including time series forecasting,+statistical hypothesis testing, Monte Carlo simulation, and scenario analysis.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Pandas DataFrame/Series with economic/financial data+ - Time series data with datetime index (for time series analysis)+ - Scenario parameters (dictionaries for scenario analysis)+ - Volatility, drift, base values (for Monte Carlo simulation)++OUTPUT:+ - Descriptive statistics (mean, median, variance, percentiles)+ - Correlation matrices with p-values+ - Hypothesis test results (t-tests, normality tests)+ - Time series forecasts (ARIMA, exponential smoothing, linear trend)+ - Monte Carlo simulation results with risk metrics+ - Scenario analysis comparisons and sensitivity results++PARAMETERS:+ - precision: Decimal precision (default: 8)+ - base_currency: Currency for calculations (default: 'USD')+ - confidence_level: Statistical confidence (default: 0.95)+ - forecast_periods: Number of periods to forecast (default: 12)+ - num_simulations: Monte Carlo simulations (default: 1000)+ - distribution: Probability distribution (default: 'normal')+"""++import numpy as np+import pandas as pd+from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any, Union, Callable+from datetime import datetime, timedelta+import warnings+from scipy import stats+from scipy.optimize import minimize+from sklearn.linear_model import LinearRegression+from sklearn.metrics import mean_squared_error, mean_absolute_error+import logging+from .core import EconomicsBase, ValidationError, CalculationError, DataError++logger = logging.getLogger(__name__)++# Suppress warnings for cleaner output+warnings.filterwarnings('ignore')+++class StatisticalAnalyzer(EconomicsBase):+ """Advanced statistical analysis for economic data"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)++ def descriptive_statistics(self, data: pd.Series,+ confidence_level: float = 0.95) -> Dict[str, Any]:+ """Calculate comprehensive descriptive statistics"""++ if data.empty:+ raise ValidationError("Empty data series provided")++ # Remove NaN values+ clean_data = data.dropna()+ if clean_data.empty:+ raise ValidationError("No valid data points after removing NaN values")++ n = len(clean_data)+ mean = clean_data.mean()+ std = clean_data.std()++ # Basic statistics+ basic_stats = {+ 'count': n,+ 'mean': self.to_decimal(mean),+ 'median': self.to_decimal(clean_data.median()),+ 'mode': self.to_decimal(clean_data.mode().iloc[0]) if not clean_data.mode().empty else None,+ 'standard_deviation': self.to_decimal(std),+ 'variance': self.to_decimal(clean_data.var()),+ 'minimum': self.to_decimal(clean_data.min()),+ 'maximum': self.to_decimal(clean_data.max()),+ 'range': self.to_decimal(clean_data.max() - clean_data.min())+ }++ # Percentiles+ percentiles = {}+ for p in [1, 5, 10, 25, 50, 75, 90, 95, 99]:+ percentiles[f'p{p}'] = self.to_decimal(clean_data.quantile(p / 100))++ # Shape statistics+ shape_stats = {+ 'skewness': self.to_decimal(clean_data.skew()),+ 'kurtosis': self.to_decimal(clean_data.kurtosis()),+ 'excess_kurtosis': self.to_decimal(clean_data.kurtosis() - 3)+ }++ # Confidence intervals+ alpha = 1 - confidence_level+ t_critical = stats.t.ppf(1 - alpha / 2, n - 1)+ margin_of_error = t_critical * (std / np.sqrt(n))++ confidence_intervals = {+ 'mean_ci_lower': self.to_decimal(mean - margin_of_error),+ 'mean_ci_upper': self.to_decimal(mean + margin_of_error),+ 'confidence_level': self.to_decimal(confidence_level)+ }++ # Normality tests+ normality_tests = self._test_normality(clean_data)++ return {+ 'basic_statistics': basic_stats,+ 'percentiles': percentiles,+ 'shape_statistics': shape_stats,+ 'confidence_intervals': confidence_intervals,+ 'normality_tests': normality_tests,+ 'outlier_analysis': self._analyze_outliers(clean_data)+ }++ def _test_normality(self, data: pd.Series) -> Dict[str, Any]:+ """Test for normality using multiple tests"""++ results = {}++ # Shapiro-Wilk test (best for small samples)+ if len(data) <= 5000:+ shapiro_stat, shapiro_p = stats.shapiro(data)+ results['shapiro_wilk'] = {+ 'statistic': self.to_decimal(shapiro_stat),+ 'p_value': self.to_decimal(shapiro_p),+ 'is_normal': shapiro_p > 0.05+ }++ # Kolmogorov-Smirnov test+ ks_stat, ks_p = stats.kstest(data, 'norm', args=(data.mean(), data.std()))+ results['kolmogorov_smirnov'] = {+ 'statistic': self.to_decimal(ks_stat),+ 'p_value': self.to_decimal(ks_p),+ 'is_normal': ks_p > 0.05+ }++ # Anderson-Darling test+ ad_stat, ad_critical, ad_significance = stats.anderson(data, dist='norm')+ results['anderson_darling'] = {+ 'statistic': self.to_decimal(ad_stat),+ 'critical_values': [self.to_decimal(cv) for cv in ad_critical],+ 'significance_levels': [self.to_decimal(sl) for sl in ad_significance],+ 'is_normal': ad_stat < ad_critical[2] # 5% significance level+ }++ return results++ def _analyze_outliers(self, data: pd.Series) -> Dict[str, Any]:+ """Analyze outliers using multiple methods"""++ # IQR method+ Q1 = data.quantile(0.25)+ Q3 = data.quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - 1.5 * IQR+ upper_bound = Q3 + 1.5 * IQR+ iqr_outliers = ((data < lower_bound) | (data > upper_bound)).sum()++ # Z-score method+ z_scores = np.abs((data - data.mean()) / data.std())+ zscore_outliers = (z_scores > 3).sum()++ # Modified Z-score method+ median = data.median()+ mad = np.median(np.abs(data - median))+ modified_z_scores = 0.6745 * (data - median) / mad+ modified_zscore_outliers = (np.abs(modified_z_scores) > 3.5).sum()++ return {+ 'iqr_method': {+ 'outlier_count': int(iqr_outliers),+ 'outlier_percentage': self.to_decimal((iqr_outliers / len(data)) * 100),+ 'lower_bound': self.to_decimal(lower_bound),+ 'upper_bound': self.to_decimal(upper_bound)+ },+ 'zscore_method': {+ 'outlier_count': int(zscore_outliers),+ 'outlier_percentage': self.to_decimal((zscore_outliers / len(data)) * 100),+ 'threshold': self.to_decimal(3)+ },+ 'modified_zscore_method': {+ 'outlier_count': int(modified_zscore_outliers),+ 'outlier_percentage': self.to_decimal((modified_zscore_outliers / len(data)) * 100),+ 'threshold': self.to_decimal(3.5)+ }+ }++ def correlation_analysis(self, data: pd.DataFrame,+ method: str = 'pearson') -> Dict[str, Any]:+ """Comprehensive correlation analysis"""++ if data.empty:+ raise ValidationError("Empty dataframe provided")++ # Select only numeric columns+ numeric_data = data.select_dtypes(include=[np.number])+ if numeric_data.empty:+ raise ValidationError("No numeric columns found in data")++ # Calculate correlation matrix+ if method.lower() == 'pearson':+ corr_matrix = numeric_data.corr(method='pearson')+ elif method.lower() == 'spearman':+ corr_matrix = numeric_data.corr(method='spearman')+ elif method.lower() == 'kendall':+ corr_matrix = numeric_data.corr(method='kendall')+ else:+ raise ValidationError(f"Unknown correlation method: {method}")++ # Calculate p-values for correlations+ p_values = self._calculate_correlation_pvalues(numeric_data, method)++ # Find significant correlations+ significant_correlations = self._find_significant_correlations(+ corr_matrix, p_values, alpha=0.05+ )++ # Identify highest correlations+ highest_correlations = self._find_highest_correlations(corr_matrix, top_n=10)++ return {+ 'correlation_matrix': corr_matrix.round(4).to_dict(),+ 'p_values': p_values,+ 'method': method,+ 'significant_correlations': significant_correlations,+ 'highest_correlations': highest_correlations,+ 'summary_statistics': {+ 'mean_correlation': self.to_decimal(+ corr_matrix.values[np.triu_indices_from(corr_matrix.values, k=1)].mean()),+ 'max_correlation': self.to_decimal(+ corr_matrix.values[np.triu_indices_from(corr_matrix.values, k=1)].max()),+ 'min_correlation': self.to_decimal(+ corr_matrix.values[np.triu_indices_from(corr_matrix.values, k=1)].min())+ }+ }++ def _calculate_correlation_pvalues(self, data: pd.DataFrame, method: str) -> Dict[str, Dict[str, float]]:+ """Calculate p-values for correlation matrix"""++ columns = data.columns+ p_values = {}++ for i, col1 in enumerate(columns):+ p_values[col1] = {}+ for j, col2 in enumerate(columns):+ if i == j:+ p_values[col1][col2] = 0.0+ else:+ if method.lower() == 'pearson':+ _, p_val = stats.pearsonr(data[col1].dropna(), data[col2].dropna())+ elif method.lower() == 'spearman':+ _, p_val = stats.spearmanr(data[col1].dropna(), data[col2].dropna())+ elif method.lower() == 'kendall':+ _, p_val = stats.kendalltau(data[col1].dropna(), data[col2].dropna())++ p_values[col1][col2] = float(p_val)++ return p_values++ def _find_significant_correlations(self, corr_matrix: pd.DataFrame,+ p_values: Dict[str, Dict[str, float]],+ alpha: float = 0.05) -> List[Dict[str, Any]]:+ """Find statistically significant correlations"""++ significant = []+ columns = corr_matrix.columns++ for i, col1 in enumerate(columns):+ for j, col2 in enumerate(columns):+ if i < j: # Avoid duplicates+ corr = corr_matrix.loc[col1, col2]+ p_val = p_values[col1][col2]++ if p_val < alpha:+ significant.append({+ 'variable_1': col1,+ 'variable_2': col2,+ 'correlation': self.to_decimal(corr),+ 'p_value': self.to_decimal(p_val),+ 'significance_level': alpha+ })++ # Sort by absolute correlation+ significant.sort(key=lambda x: abs(x['correlation']), reverse=True)++ return significant++ def _find_highest_correlations(self, corr_matrix: pd.DataFrame,+ top_n: int = 10) -> List[Dict[str, Any]]:+ """Find highest absolute correlations"""++ correlations = []+ columns = corr_matrix.columns++ for i, col1 in enumerate(columns):+ for j, col2 in enumerate(columns):+ if i < j: # Avoid duplicates+ corr = corr_matrix.loc[col1, col2]+ correlations.append({+ 'variable_1': col1,+ 'variable_2': col2,+ 'correlation': self.to_decimal(corr),+ 'absolute_correlation': self.to_decimal(abs(corr))+ })++ # Sort by absolute correlation and return top N+ correlations.sort(key=lambda x: x['absolute_correlation'], reverse=True)++ return correlations[:top_n]++ def hypothesis_testing(self, data1: pd.Series, data2: Optional[pd.Series] = None,+ test_type: str = 'one_sample_t',+ alternative: str = 'two-sided',+ alpha: float = 0.05,+ null_value: float = 0) -> Dict[str, Any]:+ """Comprehensive hypothesis testing"""++ if data1.empty:+ raise ValidationError("Empty data series provided")++ # Clean data+ clean_data1 = data1.dropna()+ if clean_data1.empty:+ raise ValidationError("No valid data points in first series")++ test_results = {}++ if test_type == 'one_sample_t':+ # One-sample t-test+ statistic, p_value = stats.ttest_1samp(clean_data1, null_value)++ test_results = {+ 'test_type': 'One-sample t-test',+ 'null_hypothesis': f'Population mean equals {null_value}',+ 'alternative_hypothesis': self._format_alternative_hypothesis('mean', null_value, alternative),+ 'test_statistic': self.to_decimal(statistic),+ 'p_value': self.to_decimal(p_value),+ 'degrees_of_freedom': len(clean_data1) - 1,+ 'sample_mean': self.to_decimal(clean_data1.mean()),+ 'sample_size': len(clean_data1)+ }++ elif test_type == 'two_sample_t':+ if data2 is None:+ raise ValidationError("Second data series required for two-sample t-test")++ clean_data2 = data2.dropna()+ if clean_data2.empty:+ raise ValidationError("No valid data points in second series")++ # Two-sample t-test (assuming unequal variances)+ statistic, p_value = stats.ttest_ind(clean_data1, clean_data2, equal_var=False)++ test_results = {+ 'test_type': 'Two-sample t-test (Welch)',+ 'null_hypothesis': 'Population means are equal',+ 'alternative_hypothesis': self._format_alternative_hypothesis('means', 0, alternative),+ 'test_statistic': self.to_decimal(statistic),+ 'p_value': self.to_decimal(p_value),+ 'sample_1_mean': self.to_decimal(clean_data1.mean()),+ 'sample_2_mean': self.to_decimal(clean_data2.mean()),+ 'sample_1_size': len(clean_data1),+ 'sample_2_size': len(clean_data2)+ }++ elif test_type == 'paired_t':+ if data2 is None:+ raise ValidationError("Second data series required for paired t-test")++ # Align the series and remove NaN pairs+ aligned_data = pd.DataFrame({'data1': data1, 'data2': data2}).dropna()+ if aligned_data.empty:+ raise ValidationError("No valid paired observations")++ statistic, p_value = stats.ttest_rel(aligned_data['data1'], aligned_data['data2'])++ test_results = {+ 'test_type': 'Paired t-test',+ 'null_hypothesis': 'Mean difference equals zero',+ 'alternative_hypothesis': self._format_alternative_hypothesis('difference', 0, alternative),+ 'test_statistic': self.to_decimal(statistic),+ 'p_value': self.to_decimal(p_value),+ 'degrees_of_freedom': len(aligned_data) - 1,+ 'mean_difference': self.to_decimal((aligned_data['data1'] - aligned_data['data2']).mean()),+ 'sample_size': len(aligned_data)+ }++ elif test_type == 'z_test':+ # One-sample z-test (requires known population standard deviation)+ pop_std = null_value # Reuse null_value parameter for population std+ if pop_std <= 0:+ raise ValidationError("Population standard deviation must be positive for z-test")++ sample_mean = clean_data1.mean()+ n = len(clean_data1)+ z_statistic = (sample_mean - null_value) / (pop_std / np.sqrt(n))++ if alternative == 'two-sided':+ p_value = 2 * (1 - stats.norm.cdf(abs(z_statistic)))+ elif alternative == 'greater':+ p_value = 1 - stats.norm.cdf(z_statistic)+ else: # 'less'+ p_value = stats.norm.cdf(z_statistic)++ test_results = {+ 'test_type': 'One-sample z-test',+ 'null_hypothesis': f'Population mean equals {null_value}',+ 'alternative_hypothesis': self._format_alternative_hypothesis('mean', null_value, alternative),+ 'test_statistic': self.to_decimal(z_statistic),+ 'p_value': self.to_decimal(p_value),+ 'sample_mean': self.to_decimal(sample_mean),+ 'population_std': self.to_decimal(pop_std),+ 'sample_size': n+ }++ else:+ raise ValidationError(f"Unknown test type: {test_type}")++ # Add common results+ test_results.update({+ 'alpha': self.to_decimal(alpha),+ 'alternative': alternative,+ 'reject_null': test_results['p_value'] < alpha,+ 'conclusion': self._generate_test_conclusion(test_results['p_value'], alpha,+ test_results['null_hypothesis'])+ })++ return test_results++ def _format_alternative_hypothesis(self, parameter: str, null_value: float, alternative: str) -> str:+ """Format alternative hypothesis string"""++ if alternative == 'two-sided':+ return f'Population {parameter} does not equal {null_value}'+ elif alternative == 'greater':+ return f'Population {parameter} is greater than {null_value}'+ elif alternative == 'less':+ return f'Population {parameter} is less than {null_value}'+ else:+ return f'Alternative hypothesis with {alternative} direction'++ def _generate_test_conclusion(self, p_value: Decimal, alpha: float, null_hypothesis: str) -> str:+ """Generate conclusion from hypothesis test"""++ if p_value < alpha:+ return f"Reject null hypothesis: {null_hypothesis} (p-value = {p_value:.6f} < α = {alpha})"+ else:+ return f"Fail to reject null hypothesis: {null_hypothesis} (p-value = {p_value:.6f} ≥ α = {alpha})"++ def time_series_analysis(self, data: pd.Series) -> Dict[str, Any]:+ """Basic time series analysis"""++ if not isinstance(data.index, pd.DatetimeIndex):+ raise ValidationError("Data must have datetime index for time series analysis")++ if data.empty:+ raise ValidationError("Empty time series provided")++ # Clean data+ clean_data = data.dropna()+ if len(clean_data) < 10:+ raise ValidationError("Insufficient data points for time series analysis")++ results = {+ 'basic_properties': {+ 'start_date': clean_data.index.min(),+ 'end_date': clean_data.index.max(),+ 'frequency': pd.infer_freq(clean_data.index),+ 'total_observations': len(clean_data),+ 'missing_observations': len(data) - len(clean_data)+ },+ 'stationarity_tests': self._test_stationarity(clean_data),+ 'autocorrelation': self._calculate_autocorrelation(clean_data),+ 'trend_analysis': self._analyze_trend(clean_data),+ 'seasonality_analysis': self._analyze_seasonality(clean_data)+ }++ return results++ def _test_stationarity(self, data: pd.Series) -> Dict[str, Any]:+ """Test for stationarity using Augmented Dickey-Fuller test"""++ from statsmodels.tsa.stattools import adfuller++ try:+ result = adfuller(data.values, autolag='AIC')++ return {+ 'adf_statistic': self.to_decimal(result[0]),+ 'p_value': self.to_decimal(result[1]),+ 'critical_values': {+ '1%': self.to_decimal(result[4]['1%']),+ '5%': self.to_decimal(result[4]['5%']),+ '10%': self.to_decimal(result[4]['10%'])+ },+ 'is_stationary': result[1] < 0.05,+ 'interpretation': 'Stationary' if result[1] < 0.05 else 'Non-stationary'+ }+ except Exception as e:+ logger.warning(f"Could not perform ADF test: {e}")+ return {'error': 'Could not perform stationarity test'}++ def _calculate_autocorrelation(self, data: pd.Series, max_lags: int = 20) -> Dict[str, Any]:+ """Calculate autocorrelation function"""++ try:+ from statsmodels.tsa.stattools import acf++ # Limit max_lags to reasonable value+ max_lags = min(max_lags, len(data) // 4)++ autocorr = acf(data.values, nlags=max_lags, alpha=0.05)++ return {+ 'autocorrelations': [self.to_decimal(x) for x in autocorr[0]],+ 'confidence_intervals': {+ 'lower': [self.to_decimal(x) for x in autocorr[1][:, 0]],+ 'upper': [self.to_decimal(x) for x in autocorr[1][:, 1]]+ },+ 'significant_lags': [i for i, ac in enumerate(autocorr[0])+ if abs(ac) > 2 / np.sqrt(len(data)) and i > 0]+ }+ except Exception as e:+ logger.warning(f"Could not calculate autocorrelation: {e}")+ return {'error': 'Could not calculate autocorrelation'}++ def _analyze_trend(self, data: pd.Series) -> Dict[str, Any]:+ """Analyze trend in time series"""++ # Linear trend using OLS+ x = np.arange(len(data))+ y = data.values++ # Fit linear regression+ slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)++ # Generate forecasts+ forecast_x = np.arange(len(data), len(data) + periods)+ forecast_values = slope * forecast_x + intercept++ return {+ 'method': 'Linear Trend',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'slope': self.to_decimal(slope),+ 'intercept': self.to_decimal(intercept),+ 'r_squared': self.to_decimal(r_value ** 2),+ 'description': 'Linear trend extrapolation'+ }++ def _exponential_smoothing_forecast(self, data: pd.Series, periods: int) -> Dict[str, Any]:+ """Simple exponential smoothing"""++ try:+ from statsmodels.tsa.holtwinters import ExponentialSmoothing++ # Fit exponential smoothing model+ model = ExponentialSmoothing(data.values, trend=None, seasonal=None)+ fitted_model = model.fit()++ # Generate forecasts+ forecast_values = fitted_model.forecast(periods)++ return {+ 'method': 'Exponential Smoothing',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'alpha': self.to_decimal(fitted_model.params['smoothing_level']),+ 'description': 'Simple exponential smoothing'+ }+ except Exception as e:+ # Fallback to manual exponential smoothing+ alpha = 0.3 # Default smoothing parameter++ # Initialize with first observation+ smoothed_values = [data.iloc[0]]++ # Calculate smoothed values+ for i in range(1, len(data)):+ smoothed_value = alpha * data.iloc[i] + (1 - alpha) * smoothed_values[-1]+ smoothed_values.append(smoothed_value)++ # Forecast using last smoothed value+ last_smoothed = smoothed_values[-1]+ forecast_values = [last_smoothed] * periods++ return {+ 'method': 'Exponential Smoothing (Manual)',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'alpha': self.to_decimal(alpha),+ 'description': 'Manual exponential smoothing implementation'+ }++ def _moving_average_forecast(self, data: pd.Series, periods: int, window: int = None) -> Dict[str, Any]:+ """Moving average forecast"""++ if window is None:+ window = min(12, len(data) // 4) # Default to 1/4 of data length, max 12++ window = max(1, min(window, len(data))) # Ensure valid window size++ # Calculate moving average+ ma_values = data.rolling(window=window).mean()+ last_ma = ma_values.iloc[-1]++ # Forecast using last moving average+ forecast_values = [last_ma] * periods++ return {+ 'method': f'Moving Average ({window} periods)',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'window_size': window,+ 'description': f'{window}-period moving average'+ }++ def _evaluate_forecasting_methods(self, data: pd.Series, forecast_periods: int,+ methods: List[str]) -> Dict[str, Any]:+ """Evaluate forecasting methods using holdout sample"""++ # Split data for evaluation+ train_size = len(data) - forecast_periods+ train_data = data.iloc[:train_size]+ test_data = data.iloc[train_size:]++ evaluation_results = {}++ for method in methods:+ try:+ # Generate forecast on training data+ if method == 'naive':+ forecast = self._naive_forecast(train_data, forecast_periods)+ elif method == 'mean':+ forecast = self._mean_forecast(train_data, forecast_periods)+ elif method == 'linear_trend':+ forecast = self._linear_trend_forecast(train_data, forecast_periods)+ elif method == 'exponential_smoothing':+ forecast = self._exponential_smoothing_forecast(train_data, forecast_periods)+ elif method == 'moving_average':+ forecast = self._moving_average_forecast(train_data, forecast_periods)+ else:+ continue++ if 'error' in forecast:+ continue++ # Calculate forecast errors+ forecast_values = [float(x) for x in forecast['forecast_values']]+ actual_values = test_data.values++ # Ensure same length+ min_length = min(len(forecast_values), len(actual_values))+ forecast_values = forecast_values[:min_length]+ actual_values = actual_values[:min_length]++ if min_length == 0:+ continue++ # Calculate error metrics+ mae = np.mean(np.abs(np.array(actual_values) - np.array(forecast_values)))+ mse = np.mean((np.array(actual_values) - np.array(forecast_values)) ** 2)+ rmse = np.sqrt(mse)++ # Mean Absolute Percentage Error+ mape = np.mean(+ np.abs((np.array(actual_values) - np.array(forecast_values)) / np.array(actual_values))) * 100++ evaluation_results[method] = {+ 'mae': self.to_decimal(mae),+ 'mse': self.to_decimal(mse),+ 'rmse': self.to_decimal(rmse),+ 'mape': self.to_decimal(mape)+ }++ except Exception as e:+ logger.error(f"Error evaluating {method}: {e}")+ evaluation_results[method] = {'error': str(e)}++ # Find best method based on RMSE+ if evaluation_results:+ best_method = min(evaluation_results.keys(),+ key=lambda k: evaluation_results[k].get('rmse', float('inf'))+ if 'error' not in evaluation_results[k] else float('inf'))++ return {+ 'method_performance': evaluation_results,+ 'best_method': best_method,+ 'evaluation_period': forecast_periods+ }++ return {'error': 'Could not evaluate any methods'}++ def arima_forecast(self, data: pd.Series, forecast_periods: int = 12,+ order: Tuple[int, int, int] = None,+ auto_arima: bool = True) -> Dict[str, Any]:+ """ARIMA forecasting"""++ if data.empty:+ raise ValidationError("Empty time series provided")++ clean_data = data.dropna()+ if len(clean_data) < 20:+ raise ValidationError("Insufficient data for ARIMA modeling (need at least 20 observations)")++ try:+ from statsmodels.tsa.arima.model import ARIMA++ if auto_arima and order is None:+ # Simple auto-ARIMA using AIC+ best_aic = float('inf')+ best_order = (1, 1, 1)++ # Try different combinations+ for p in range(0, 4):+ for d in range(0, 2):+ for q in range(0, 4):+ try:+ model = ARIMA(clean_data, order=(p, d, q))+ fitted_model = model.fit()+ if fitted_model.aic < best_aic:+ best_aic = fitted_model.aic+ best_order = (p, d, q)+ except:+ continue++ order = best_order+ elif order is None:+ order = (1, 1, 1) # Default ARIMA(1,1,1)++ # Fit ARIMA model+ model = ARIMA(clean_data, order=order)+ fitted_model = model.fit()++ # Generate forecasts+ forecast_result = fitted_model.forecast(steps=forecast_periods)+ confidence_intervals = fitted_model.get_forecast(steps=forecast_periods).conf_int()++ return {+ 'method': f'ARIMA{order}',+ 'forecast_values': [self.to_decimal(x) for x in forecast_result],+ 'confidence_intervals': {+ 'lower': [self.to_decimal(x) for x in confidence_intervals.iloc[:, 0]],+ 'upper': [self.to_decimal(x) for x in confidence_intervals.iloc[:, 1]]+ },+ 'model_order': order,+ 'aic': self.to_decimal(fitted_model.aic),+ 'bic': self.to_decimal(fitted_model.bic),+ 'log_likelihood': self.to_decimal(fitted_model.llf),+ 'description': f'ARIMA({order[0]},{order[1]},{order[2]}) model'+ }++ except ImportError:+ raise DataError("statsmodels package required for ARIMA forecasting")+ except Exception as e:+ raise CalculationError(f"ARIMA forecasting failed: {e}")++ def calculate(self, forecast_type: str, **kwargs) -> Dict[str, Any]:+ """Main forecasting dispatcher"""++ forecasts = {+ 'simple_methods': lambda: self.simple_forecasting_methods(+ kwargs['data'], kwargs.get('forecast_periods', 12),+ kwargs.get('methods')+ ),+ 'arima': lambda: self.arima_forecast(+ kwargs['data'], kwargs.get('forecast_periods', 12),+ kwargs.get('order'), kwargs.get('auto_arima', True)+ )+ }++ if forecast_type not in forecasts:+ raise ValidationError(f"Unknown forecast type: {forecast_type}")++ result = forecasts[forecast_type]()+ result['metadata'] = self.get_metadata()+ result['forecast_type'] = forecast_type++ return result+++class ScenarioAnalyzer(EconomicsBase):+ """Scenario analysis and Monte Carlo simulation"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)++ def monte_carlo_simulation(self, base_value: float,+ volatility: float,+ drift: float = 0.0,+ time_periods: int = 252,+ num_simulations: int = 1000,+ distribution: str = 'normal') -> Dict[str, Any]:+ """Monte Carlo simulation for economic variables"""++ if num_simulations < 100:+ raise ValidationError("Number of simulations must be at least 100")++ if time_periods < 1:+ raise ValidationError("Time periods must be positive")++ np.random.seed(42) # For reproducibility++ # Generate random shocks+ if distribution.lower() == 'normal':+ random_shocks = np.random.normal(0, 1, (num_simulations, time_periods))+ elif distribution.lower() == 'student_t':+ df = 5 # degrees of freedom for t-distribution+ random_shocks = np.random.standard_t(df, (num_simulations, time_periods))+ else:+ raise ValidationError(f"Unknown distribution: {distribution}")++ # Initialize simulation matrix+ simulations = np.zeros((num_simulations, time_periods + 1))+ simulations[:, 0] = base_value++ # Run simulations (Geometric Brownian Motion)+ dt = 1.0 / time_periods # Time step++ for t in range(time_periods):+ # dS = S * (drift * dt + volatility * sqrt(dt) * random_shock)+ returns = drift * dt + volatility * np.sqrt(dt) * random_shocks[:, t]+ simulations[:, t + 1] = simulations[:, t] * (1 + returns)++ # Calculate statistics+ final_values = simulations[:, -1]++ percentiles = {}+ for p in [1, 5, 10, 25, 50, 75, 90, 95, 99]:+ percentiles[f'p{p}'] = self.to_decimal(np.percentile(final_values, p))++ # Value at Risk calculations+ var_95 = np.percentile(final_values, 5) # 5th percentile+ var_99 = np.percentile(final_values, 1) # 1st percentile++ # Expected shortfall (Conditional VaR)+ es_95 = np.mean(final_values[final_values <= var_95])+ es_99 = np.mean(final_values[final_values <= var_99])++ # Path statistics+ max_values = np.max(simulations, axis=1)+ min_values = np.min(simulations, axis=1)++ return {+ 'simulation_parameters': {+ 'base_value': self.to_decimal(base_value),+ 'volatility': self.to_decimal(volatility),+ 'drift': self.to_decimal(drift),+ 'time_periods': time_periods,+ 'num_simulations': num_simulations,+ 'distribution': distribution+ },+ 'final_value_statistics': {+ 'mean': self.to_decimal(np.mean(final_values)),+ 'median': self.to_decimal(np.median(final_values)),+ 'std': self.to_decimal(np.std(final_values)),+ 'min': self.to_decimal(np.min(final_values)),+ 'max': self.to_decimal(np.max(final_values)),+ 'percentiles': percentiles+ },+ 'risk_metrics': {+ 'var_95': self.to_decimal(var_95),+ 'var_99': self.to_decimal(var_99),+ 'expected_shortfall_95': self.to_decimal(es_95),+ 'expected_shortfall_99': self.to_decimal(es_99),+ 'probability_of_loss': self.to_decimal(np.mean(final_values < base_value) * 100)+ },+ 'path_statistics': {+ 'max_value_mean': self.to_decimal(np.mean(max_values)),+ 'min_value_mean': self.to_decimal(np.mean(min_values)),+ 'max_drawdown_mean': self.to_decimal(np.mean((max_values - min_values) / max_values * 100))+ }+ }++ def scenario_analysis(self, base_case: Dict[str, float],+ scenarios: Dict[str, Dict[str, float]],+ model_function: Callable,+ sensitivity_vars: List[str] = None) -> Dict[str, Any]:+ """Comprehensive scenario analysis"""++ if not scenarios:+ raise ValidationError("At least one scenario must be provided")++ # Calculate base case+ try:+ base_result = model_function(**base_case)+ except Exception as e:+ raise CalculationError(f"Error calculating base case: {e}")++ # Calculate scenarios+ scenario_results = {}+ for scenario_name, scenario_params in scenarios.items():+ try:+ # Merge base case with scenario parameters+ scenario_inputs = {**base_case, **scenario_params}+ scenario_result = model_function(**scenario_inputs)+ scenario_results[scenario_name] = scenario_result+ except Exception as e:+ logger.error(f"Error calculating scenario {scenario_name}: {e}")+ scenario_results[scenario_name] = {'error': str(e)}++ # Sensitivity analysis if requested+ sensitivity_results = None+ if sensitivity_vars:+ sensitivity_results = self._sensitivity_analysis(+ base_case, model_function, sensitivity_vars+ )++ return {+ 'base_case': {+ 'inputs': base_case,+ 'result': base_result+ },+ 'scenarios': {+ name: {+ 'inputs': {**base_case, **scenarios[name]},+ 'result': result+ }+ for name, result in scenario_results.items()+ },+ 'sensitivity_analysis': sensitivity_results,+ 'scenario_comparison': self._compare_scenarios(base_result, scenario_results)+ }++ def _sensitivity_analysis(self, base_case: Dict[str, float],+ model_function: Callable,+ variables: List[str],+ shock_size: float = 0.1) -> Dict[str, Any]:+ """Perform sensitivity analysis"""++ sensitivity_results = {}++ for var in variables:+ if var not in base_case:+ logger.warning(f"Variable {var} not found in base case")+ continue++ base_value = base_case[var]++ # Positive shock+ shocked_inputs_pos = base_case.copy()+ shocked_inputs_pos[var] = base_value * (1 + shock_size)++ # Negative shock+ shocked_inputs_neg = base_case.copy()+ shocked_inputs_neg[var] = base_value * (1 - shock_size)++ try:+ base_result = model_function(**base_case)+ result_pos = model_function(**shocked_inputs_pos)+ result_neg = model_function(**shocked_inputs_neg)++ # Calculate elasticity (percentage change in result / percentage change in input)+ if isinstance(base_result, dict):+ # If result is a dictionary, calculate sensitivity for each output+ var_sensitivity = {}+ for output_var, base_output in base_result.items():+ if isinstance(base_output, (int, float)):+ elasticity_pos = ((result_pos[output_var] - base_output) / base_output) / shock_size+ elasticity_neg = ((result_neg[output_var] - base_output) / base_output) / (-shock_size)+ avg_elasticity = (elasticity_pos + elasticity_neg) / 2++ var_sensitivity[output_var] = {+ 'elasticity': self.to_decimal(avg_elasticity),+ 'positive_shock_result': self.to_decimal(result_pos[output_var]),+ 'negative_shock_result': self.to_decimal(result_neg[output_var])+ }+ else:+ # Single output value+ elasticity_pos = ((result_pos - base_result) / base_result) / shock_size+ elasticity_neg = ((result_neg - base_result) / base_result) / (-shock_size)+ avg_elasticity = (elasticity_pos + elasticity_neg) / 2++ var_sensitivity = {+ 'elasticity': self.to_decimal(avg_elasticity),+ 'positive_shock_result': self.to_decimal(result_pos),+ 'negative_shock_result': self.to_decimal(result_neg)+ }++ sensitivity_results[var] = var_sensitivity++ except Exception as e:+ logger.error(f"Error in sensitivity analysis for {var}: {e}")+ sensitivity_results[var] = {'error': str(e)}++ return sensitivity_results++ def _compare_scenarios(self, base_result: Any, scenario_results: Dict[str, Any]) -> Dict[str, Any]:+ """Compare scenario results to base case"""++ comparisons = {}++ for scenario_name, scenario_result in scenario_results.items():+ if 'error' in str(scenario_result):+ comparisons[scenario_name] = {'error': 'Could not compare due to calculation error'}+ continue++ try:+ if isinstance(base_result, dict) and isinstance(scenario_result, dict):+ # Compare dictionary results+ scenario_comparison = {}+ for key in base_result.keys():+ if key in scenario_result and isinstance(base_result[key], (int, float)):+ base_val = base_result[key]+ scenario_val = scenario_result[key]++ absolute_change = scenario_val - base_val+ percentage_change = (absolute_change / base_val * 100) if base_val != 0 else 0++ scenario_comparison[key] = {+ 'base_value': self.to_decimal(base_val),+ 'scenario_value': self.to_decimal(scenario_val),+ 'absolute_change': self.to_decimal(absolute_change),+ 'percentage_change': self.to_decimal(percentage_change)+ }++ comparisons[scenario_name] = scenario_comparison++ elif isinstance(base_result, (int, float)) and isinstance(scenario_result, (int, float)):+ # Compare single values+ absolute_change = scenario_result - base_result+ percentage_change = (absolute_change / base_result * 100) if base_result != 0 else 0++ comparisons[scenario_name] = {+ 'base_value': self.to_decimal(base_result),+ 'scenario_value': self.to_decimal(scenario_result),+ 'absolute_change': self.to_decimal(absolute_change),+ 'percentage_change': self.to_decimal(percentage_change)+ }++ except Exception as e:+ logger.error(f"Error comparing scenario {scenario_name}: {e}")+ comparisons[scenario_name] = {'error': str(e)}++ return comparisons++ def stress_testing(self, base_parameters: Dict[str, float],+ stress_scenarios: Dict[str, Dict[str, float]],+ model_function: Callable,+ risk_thresholds: Dict[str, float] = None) -> Dict[str, Any]:+ """Comprehensive stress testing"""++ # Standard stress scenarios if none provided+ if not stress_scenarios:+ stress_scenarios = {+ 'mild_stress': {var: val * 0.9 for var, val in base_parameters.items()},+ 'moderate_stress': {var: val * 0.8 for var, val in base_parameters.items()},+ 'severe_stress': {var: val * 0.7 for var, val in base_parameters.items()},+ 'extreme_stress': {var: val * 0.5 for var, val in base_parameters.items()}+ }++ # Run stress scenarios+ stress_results = {}+ base_result = model_function(**base_parameters)++ for stress_name, stress_params in stress_scenarios.items():+ try:+ stressed_inputs = {**base_parameters, **stress_params}+ stress_result = model_function(**stressed_inputs)+ stress_results[stress_name] = stress_result+ except Exception as e:+ logger.error(f"Error in stress scenario {stress_name}: {e}")+ stress_results[stress_name] = {'error': str(e)}++ # Assess risk threshold breaches+ threshold_analysis = None+ if risk_thresholds:+ threshold_analysis = self._analyze_threshold_breaches(+ base_result, stress_results, risk_thresholds+ )++ return {+ 'base_case': base_result,+ 'stress_scenarios': stress_results,+ 'threshold_analysis': threshold_analysis,+ 'stress_summary': self._summarize_stress_results(base_result, stress_results)+ }++ def _analyze_threshold_breaches(self, base_result: Any,+ stress_results: Dict[str, Any],+ thresholds: Dict[str, float]) -> Dict[str, Any]:+ """Analyze threshold breaches in stress scenarios"""++ breaches = {}++ for scenario_name, scenario_result in stress_results.items():+ if 'error' in str(scenario_result):+ continue++ scenario_breaches = {}++ if isinstance(scenario_result, dict):+ for var, threshold in thresholds.items():+ if var in scenario_result:+ value = scenario_result[var]+ breach = value < threshold+ scenario_breaches[var] = {+ 'threshold': self.to_decimal(threshold),+ 'actual_value': self.to_decimal(value),+ 'breach': breach,+ 'distance_from_threshold': self.to_decimal(value - threshold)+ }++ breaches[scenario_name] = scenario_breaches++ return breaches++ def _summarize_stress_results(self, base_result: Any,+ stress_results: Dict[str, Any]) -> Dict[str, Any]:+ """Summarize stress testing results"""++ if isinstance(base_result, dict):+ # Multi-variable case+ summary = {}+ for var in base_result.keys():+ if isinstance(base_result[var], (int, float)):+ var_results = []+ for scenario_result in stress_results.values():+ if isinstance(scenario_result, dict) and var in scenario_result:+ var_results.append(scenario_result[var])++ if var_results:+ summary[var] = {+ 'base_value': self.to_decimal(base_result[var]),+ 'worst_case': self.to_decimal(min(var_results)),+ 'best_case': self.to_decimal(max(var_results)),+ 'average_stress': self.to_decimal(np.mean(var_results)),+ 'max_decline': self.to_decimal(base_result[var] - min(var_results))+ }+ return summary+ else:+ # Single variable case+ valid_results = [r for r in stress_results.values() if 'error' not in str(r)]++ if valid_results:+ return {+ 'base_value': self.to_decimal(base_result),+ 'worst_case': self.to_decimal(min(valid_results)),+ 'best_case': self.to_decimal(max(valid_results)),+ 'average_stress': self.to_decimal(np.mean(valid_results)),+ 'max_decline': self.to_decimal(base_result - min(valid_results))+ }++ return {'error': 'No valid stress results to summarize'}++ def calculate(self, analysis_type: str, **kwargs) -> Dict[str, Any]:+ """Main scenario analysis dispatcher"""++ analyses = {+ 'monte_carlo': lambda: self.monte_carlo_simulation(+ kwargs['base_value'], kwargs['volatility'], kwargs.get('drift', 0.0),+ kwargs.get('time_periods', 252), kwargs.get('num_simulations', 1000),+ kwargs.get('distribution', 'normal')+ ),+ 'scenario_analysis': lambda: self.scenario_analysis(+ kwargs['base_case'], kwargs['scenarios'], kwargs['model_function'],+ kwargs.get('sensitivity_vars')+ ),+ 'stress_testing': lambda: self.stress_testing(+ kwargs['base_parameters'], kwargs.get('stress_scenarios', {}),+ kwargs['model_function'], kwargs.get('risk_thresholds')+ )+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ result['analysis_type'] = analysis_type++ return result++ slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)++ # Calculate trend strength+ trend_strength = abs(r_value)++ return {+ 'linear_trend': {+ 'slope': self.to_decimal(slope),+ 'intercept': self.to_decimal(intercept),+ 'r_squared': self.to_decimal(r_value ** 2),+ 'p_value': self.to_decimal(p_value),+ 'standard_error': self.to_decimal(std_err)+ },+ 'trend_direction': 'Increasing' if slope > 0 else 'Decreasing' if slope < 0 else 'Flat',+ 'trend_strength': self.to_decimal(trend_strength),+ 'trend_significance': p_value < 0.05+ }++ def _analyze_seasonality(self, data: pd.Series) -> Dict[str, Any]:+ """Analyze seasonality in time series"""++ if len(data) < 24: # Need at least 2 years of monthly data+ return {'error': 'Insufficient data for seasonality analysis'}++ try:+ from statsmodels.tsa.seasonal import seasonal_decompose++ # Infer frequency for decomposition+ freq = pd.infer_freq(data.index)+ if freq is None:+ # Try to infer period based on data length+ if len(data) >= 365:+ period = 365 # Daily data, yearly seasonality+ elif len(data) >= 52:+ period = 52 # Weekly data, yearly seasonality+ elif len(data) >= 12:+ period = 12 # Monthly data, yearly seasonality+ else:+ period = 4 # Quarterly data+ else:+ period = None++ decomposition = seasonal_decompose(data, model='additive', period=period)++ # Calculate seasonality strength+ seasonal_var = np.var(decomposition.seasonal.dropna())+ residual_var = np.var(decomposition.resid.dropna())+ seasonality_strength = seasonal_var / (seasonal_var + residual_var)++ return {+ 'seasonality_detected': seasonality_strength > 0.1,+ 'seasonality_strength': self.to_decimal(seasonality_strength),+ 'seasonal_period': period,+ 'components_variance': {+ 'trend': self.to_decimal(np.var(decomposition.trend.dropna())),+ 'seasonal': self.to_decimal(seasonal_var),+ 'residual': self.to_decimal(residual_var)+ }+ }+ except Exception as e:+ logger.warning(f"Could not perform seasonality analysis: {e}")+ return {'error': 'Could not perform seasonality analysis'}++ def calculate(self, analysis_type: str, **kwargs) -> Dict[str, Any]:+ """Main statistical analysis dispatcher"""++ analyses = {+ 'descriptive_statistics': lambda: self.descriptive_statistics(+ kwargs['data'], kwargs.get('confidence_level', 0.95)+ ),+ 'correlation_analysis': lambda: self.correlation_analysis(+ kwargs['data'], kwargs.get('method', 'pearson')+ ),+ 'hypothesis_testing': lambda: self.hypothesis_testing(+ kwargs['data1'], kwargs.get('data2'), kwargs.get('test_type', 'one_sample_t'),+ kwargs.get('alternative', 'two-sided'), kwargs.get('alpha', 0.05),+ kwargs.get('null_value', 0)+ ),+ 'time_series_analysis': lambda: self.time_series_analysis(kwargs['data'])+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ result['analysis_type'] = analysis_type++ return result+++class ForecastingEngine(EconomicsBase):+ """Economic forecasting using various methods"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)++ def simple_forecasting_methods(self, data: pd.Series,+ forecast_periods: int = 12,+ methods: List[str] = None) -> Dict[str, Any]:+ """Simple forecasting methods for economic time series"""++ if data.empty:+ raise ValidationError("Empty time series provided")++ # Clean data+ clean_data = data.dropna()+ if len(clean_data) < 5:+ raise ValidationError("Insufficient data for forecasting")++ if methods is None:+ methods = ['naive', 'mean', 'linear_trend', 'exponential_smoothing']++ forecasts = {}++ for method in methods:+ try:+ if method == 'naive':+ forecasts[method] = self._naive_forecast(clean_data, forecast_periods)+ elif method == 'mean':+ forecasts[method] = self._mean_forecast(clean_data, forecast_periods)+ elif method == 'linear_trend':+ forecasts[method] = self._linear_trend_forecast(clean_data, forecast_periods)+ elif method == 'exponential_smoothing':+ forecasts[method] = self._exponential_smoothing_forecast(clean_data, forecast_periods)+ elif method == 'moving_average':+ forecasts[method] = self._moving_average_forecast(clean_data, forecast_periods)+ else:+ logger.warning(f"Unknown forecasting method: {method}")++ except Exception as e:+ logger.error(f"Error in {method} forecasting: {e}")+ forecasts[method] = {'error': str(e)}++ # Generate forecast evaluation if we have enough data+ evaluation = None+ if len(clean_data) > forecast_periods * 2:+ evaluation = self._evaluate_forecasting_methods(clean_data, forecast_periods, methods)++ return {+ 'forecasts': forecasts,+ 'forecast_periods': forecast_periods,+ 'data_length': len(clean_data),+ 'methods_used': methods,+ 'evaluation': evaluation+ }++ def _naive_forecast(self, data: pd.Series, periods: int) -> Dict[str, Any]:+ """Naive forecast - last value carried forward"""++ last_value = data.iloc[-1]+ forecast_values = [last_value] * periods++ return {+ 'method': 'Naive (Random Walk)',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'description': 'Last observed value carried forward'+ }++ def _mean_forecast(self, data: pd.Series, periods: int) -> Dict[str, Any]:+ """Mean forecast - historical mean"""++ mean_value = data.mean()+ forecast_values = [mean_value] * periods++ return {+ 'method': 'Historical Mean',+ 'forecast_values': [self.to_decimal(x) for x in forecast_values],+ 'description': 'Historical average carried forward'+ }++ def _linear_trend_forecast(self, data: pd.Series, periods: int) -> Dict[str, Any]:+ """Linear trend extrapolation"""++ x = np.arange(len(data))+ y = data.values\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/capital_flows.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/capital_flows.pynew file mode 100644index 000000000..168f2327d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/capital_flows.py@@ -0,0 +1,1162 @@+"""+Capital Flows and Foreign Exchange Analytics Module+===================================================++Comprehensive analysis of capital flows, foreign exchange markets, and exchange rate regimes. Implements CFA Institute curriculum for capital flow analysis, FX market structure, currency movements, and balance of payments dynamics.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Balance of payments statistics and current account data+ - Capital flow breakdowns (FDI, portfolio, other investments)+ - Foreign exchange market data and trading volumes+ - Exchange rate series and currency pair information+ - Interest rate differentials and monetary policy data+ - Central bank intervention and reserve data+ - Capital restriction and regulatory information++OUTPUT:+ - Capital flow analysis and sustainability assessments+ - FX market structure and participant analysis+ - Exchange rate regime evaluation and policy recommendations+ - Currency movement calculations and economic impact assessments+ - Balance of payments equilibrium analysis+ - Capital restriction effectiveness evaluations+ - Early warning indicators for currency crises++PARAMETERS:+ - fdi_inflows_gdp: FDI inflows as percentage of GDP+ - portfolio_flows_gdp: Portfolio flows as percentage of GDP+ - current_account_gdp: Current account balance as percentage of GDP+ - capital_account_gdp: Capital account balance as percentage of GDP+ - foreign_debt_gdp: External debt as percentage of GDP+ - reserves_months_imports: Foreign reserves in months of imports+ - daily_volume: Daily FX trading volume+ - nominal_rate: Nominal exchange rate+ - initial_rate: Initial exchange rate for change calculations+ - final_rate: Final exchange rate for change calculations+ - flow_data: Dictionary containing capital flow statistics+ - bop_data: Dictionary containing balance of payments data+ - restriction_data: Dictionary containing capital restriction information+"""++from decimal import Decimal+from typing import Dict, List, Any, Tuple+from datetime import datetime+from .core import EconomicsBase, ValidationError, CalculationError+++class CapitalFlowAnalyzer(EconomicsBase):+ """Capital flows analysis and balance of payments impact"""++ def analyze_capital_flow_types(self, flow_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze different types of capital flows and their characteristics"""+ return {+ 'foreign_direct_investment': {+ 'definition': 'Long-term investment for control or significant influence (>10% ownership)',+ 'characteristics': [+ 'Long-term commitment and stability',+ 'Technology and knowledge transfer',+ 'Management expertise and best practices',+ 'Difficult to reverse quickly'+ ],+ 'economic_impact': {+ 'positive': 'Productivity gains, employment creation, export growth',+ 'negative': 'Potential crowding out of domestic investment',+ 'volatility': 'Low - stable funding source'+ },+ 'current_flows': self._analyze_fdi_flows(flow_data),+ 'policy_implications': 'Generally welcomed, policies focus on attraction and retention'+ },+ 'portfolio_investment': {+ 'definition': 'Investment in securities without control (<10% ownership)',+ 'characteristics': [+ 'Liquid and easily reversible',+ 'Driven by return differentials and risk appetite',+ 'Sensitive to market sentiment',+ 'Includes equity and debt securities'+ ],+ 'economic_impact': {+ 'positive': 'Capital market development, financing access',+ 'negative': 'Volatility and sudden stops risk',+ 'volatility': 'High - subject to rapid reversals'+ },+ 'current_flows': self._analyze_portfolio_flows(flow_data),+ 'policy_implications': 'Requires robust regulatory framework and macroprudential policies'+ },+ 'other_investment': {+ 'definition': 'Bank lending, trade credits, and other financial flows',+ 'characteristics': [+ 'Includes bank loans and deposits',+ 'Trade finance and short-term credits',+ 'Interbank and intercompany lending',+ 'Often procyclical'+ ],+ 'economic_impact': {+ 'positive': 'Trade finance facilitation, liquidity provision',+ 'negative': 'Banking sector vulnerabilities, sudden stops',+ 'volatility': 'Medium to High - depends on banking conditions'+ },+ 'current_flows': self._analyze_other_flows(flow_data),+ 'policy_implications': 'Banking supervision and capital flow management'+ },+ 'official_flows': {+ 'definition': 'Central bank and government transactions',+ 'characteristics': [+ 'Reserve accumulation/depletion',+ 'Official development assistance',+ 'Bilateral government lending',+ 'IMF and multilateral lending'+ ],+ 'economic_impact': {+ 'positive': 'Crisis support, development financing',+ 'negative': 'May create moral hazard',+ 'volatility': 'Low to Medium - policy driven'+ },+ 'policy_implications': 'Part of macroeconomic management and development strategy'+ },+ 'flow_determinants': self._analyze_flow_determinants(flow_data),+ 'volatility_comparison': self._compare_flow_volatility(),+ 'crisis_behavior': self._analyze_crisis_behavior()+ }++ def analyze_balance_of_payments_impact(self, bop_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze how BOP flows affect exchange rates"""+ return {+ 'current_account_impact': {+ 'trade_balance': {+ 'surplus_effect': 'Creates demand for domestic currency',+ 'deficit_effect': 'Creates supply of domestic currency',+ 'elasticity_considerations': 'J-curve effect in short run',+ 'current_balance': self._assess_trade_balance_impact(bop_data)+ },+ 'income_flows': {+ 'investment_income': 'Returns on foreign investments affect currency demand',+ 'compensation': 'Worker remittances and cross-border wages',+ 'impact_assessment': self._assess_income_flows_impact(bop_data)+ },+ 'transfers': {+ 'remittances': 'Significant for many developing countries',+ 'official_transfers': 'Aid and government transfers',+ 'impact_assessment': self._assess_transfer_impact(bop_data)+ }+ },+ 'capital_account_impact': {+ 'direct_investment': {+ 'fx_impact': 'Usually strengthens recipient currency',+ 'timing': 'Gradual impact as investments are made',+ 'sustainability': 'Most stable form of capital flow'+ },+ 'portfolio_investment': {+ 'fx_impact': 'Can cause rapid currency movements',+ 'timing': 'Immediate impact on exchange rates',+ 'volatility': 'High sensitivity to sentiment changes'+ },+ 'financial_derivatives': {+ 'fx_impact': 'Complex, depends on underlying positions',+ 'hedging_flows': 'May offset other capital flows'+ },+ 'reserve_changes': {+ 'intervention_impact': 'Central bank buying/selling affects rates',+ 'signaling_effect': 'Indicates policy stance and credibility'+ }+ },+ 'bop_equilibrium_analysis': self._analyze_bop_equilibrium(bop_data),+ 'sustainability_assessment': self._assess_bop_sustainability(bop_data),+ 'policy_responses': self._recommend_bop_policies(bop_data)+ }++ def assess_capital_restrictions(self, restriction_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze government capital restrictions and their objectives"""+ return {+ 'restriction_types': {+ 'inflow_controls': {+ 'objectives': [+ 'Prevent asset bubbles from hot money',+ 'Maintain monetary policy independence',+ 'Reduce financial stability risks',+ 'Prevent real exchange rate appreciation'+ ],+ 'instruments': [+ 'Unremunerated reserve requirements',+ 'Taxes on foreign investment',+ 'Minimum holding periods',+ 'Limits on foreign ownership'+ ],+ 'effectiveness': self._assess_inflow_control_effectiveness(restriction_data)+ },+ 'outflow_controls': {+ 'objectives': [+ 'Prevent capital flight during crises',+ 'Preserve foreign exchange reserves',+ 'Maintain exchange rate stability',+ 'Support domestic financing needs'+ ],+ 'instruments': [+ 'Approval requirements for foreign investment',+ 'Limits on foreign currency holdings',+ 'Restrictions on overseas deposits',+ 'Export surrender requirements'+ ],+ 'effectiveness': self._assess_outflow_control_effectiveness(restriction_data)+ }+ },+ 'common_objectives': {+ 'macroeconomic_stability': 'Maintain stable exchange rates and inflation',+ 'financial_stability': 'Prevent excessive risk-taking and bubbles',+ 'monetary_independence': 'Preserve domestic monetary policy effectiveness',+ 'development_goals': 'Channel capital toward productive investments',+ 'crisis_prevention': 'Reduce vulnerability to sudden stops'+ },+ 'effectiveness_factors': {+ 'comprehensiveness': 'Controls must cover all relevant channels',+ 'enforceability': 'Administrative capacity and compliance monitoring',+ 'market_development': 'May hinder financial market development',+ 'evasion_potential': 'Sophisticated investors can often circumvent controls',+ 'international_coordination': 'Effectiveness increases with coordination'+ },+ 'costs_and_benefits': self._analyze_restriction_costs_benefits(),+ 'optimal_design_principles': self._recommend_optimal_design(),+ 'current_trends': self._analyze_current_restriction_trends()+ }++ def _analyze_fdi_flows(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze FDI flow characteristics"""+ fdi_inflows = self.to_decimal(data.get('fdi_inflows_gdp', 0))+ fdi_outflows = self.to_decimal(data.get('fdi_outflows_gdp', 0))++ return {+ 'inflow_level': f"{fdi_inflows:.1f}% of GDP",+ 'outflow_level': f"{fdi_outflows:.1f}% of GDP",+ 'net_position': f"{fdi_inflows - fdi_outflows:.1f}% of GDP",+ 'assessment': self._assess_fdi_level(fdi_inflows),+ 'sectoral_distribution': data.get('fdi_sectors', 'Mixed across sectors')+ }++ def _analyze_portfolio_flows(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze portfolio flow characteristics"""+ portfolio_flows = self.to_decimal(data.get('portfolio_flows_gdp', 0))+ volatility = data.get('portfolio_volatility', 'High')++ return {+ 'flow_level': f"{portfolio_flows:.1f}% of GDP",+ 'volatility_assessment': volatility,+ 'composition': data.get('portfolio_composition', 'Mixed equity and debt'),+ 'vulnerability_indicator': self._assess_portfolio_vulnerability(portfolio_flows)+ }++ def _analyze_other_flows(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze other investment flows"""+ other_flows = self.to_decimal(data.get('other_investment_gdp', 0))++ return {+ 'flow_level': f"{other_flows:.1f}% of GDP",+ 'banking_component': data.get('banking_flows_share', 'Significant'),+ 'trade_finance_component': data.get('trade_finance_share', 'Moderate'),+ 'stability_assessment': self._assess_other_flow_stability(other_flows)+ }++ def _analyze_flow_determinants(self, data: Dict[str, Any]) -> Dict[str, List[str]]:+ """Analyze determinants of capital flows"""+ return {+ 'push_factors': [+ 'Global risk appetite and liquidity conditions',+ 'Advanced economy interest rates',+ 'Global growth and commodity prices',+ 'Investor risk tolerance'+ ],+ 'pull_factors': [+ 'Domestic economic fundamentals',+ 'Interest rate differentials',+ 'Exchange rate expectations',+ 'Political and institutional quality',+ 'Market development and accessibility'+ ],+ 'structural_factors': [+ 'Trade openness and integration',+ 'Financial market development',+ 'Capital account openness',+ 'Institutional quality and governance'+ ]+ }++ def _compare_flow_volatility(self) -> Dict[str, str]:+ """Compare volatility across flow types"""+ return {+ 'most_volatile': 'Portfolio investment (especially equity)',+ 'moderately_volatile': 'Other investment (banking flows)',+ 'least_volatile': 'Foreign direct investment',+ 'crisis_behavior': 'Portfolio flows show strongest sudden stop tendency'+ }++ def _analyze_crisis_behavior(self) -> Dict[str, str]:+ """Analyze capital flow behavior during crises"""+ return {+ 'sudden_stops': 'Rapid reversal of portfolio and banking flows',+ 'flight_to_quality': 'Shift from emerging to developed markets',+ 'fdi_resilience': 'FDI typically more stable during crises',+ 'contagion_channels': 'Capital flows can transmit crises across countries'+ }++ def _assess_trade_balance_impact(self, data: Dict[str, Any]) -> str:+ """Assess trade balance impact on exchange rates"""+ trade_balance = self.to_decimal(data.get('trade_balance_gdp', 0))++ if trade_balance > self.to_decimal(2):+ return 'Large surplus likely supporting currency'+ elif trade_balance < self.to_decimal(-5):+ return 'Large deficit creating downward pressure on currency'+ else:+ return 'Moderate trade balance with limited FX impact'++ def _assess_income_flows_impact(self, data: Dict[str, Any]) -> str:+ """Assess income flows impact"""+ income_balance = self.to_decimal(data.get('income_balance_gdp', 0))++ if income_balance > self.to_decimal(1):+ return 'Positive income flows supporting currency'+ elif income_balance < self.to_decimal(-2):+ return 'Negative income flows pressuring currency'+ else:+ return 'Income flows have moderate impact'++ def _assess_transfer_impact(self, data: Dict[str, Any]) -> str:+ """Assess transfer impact on currency"""+ transfers = self.to_decimal(data.get('transfers_gdp', 0))++ if transfers > self.to_decimal(3):+ return 'Significant remittances providing currency support'+ else:+ return 'Transfers have limited currency impact'++ def _analyze_bop_equilibrium(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze balance of payments equilibrium"""+ current_account = self.to_decimal(data.get('current_account_gdp', 0))+ capital_account = self.to_decimal(data.get('capital_account_gdp', 0))++ return {+ 'current_account_balance': f"{current_account:.1f}% of GDP",+ 'capital_account_balance': f"{capital_account:.1f}% of GDP",+ 'overall_balance': f"{current_account + capital_account:.1f}% of GDP",+ 'equilibrium_assessment': self._assess_bop_equilibrium_status(current_account, capital_account),+ 'reserve_implications': self._assess_reserve_implications(current_account + capital_account)+ }++ def _assess_bop_sustainability(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess BOP sustainability"""+ current_account = self.to_decimal(data.get('current_account_gdp', 0))+ foreign_debt = self.to_decimal(data.get('foreign_debt_gdp', 0))++ return {+ 'current_account_sustainability': self._assess_ca_sustainability(current_account),+ 'external_debt_sustainability': self._assess_debt_sustainability(foreign_debt),+ 'vulnerability_indicators': self._identify_vulnerability_indicators(data),+ 'early_warning_signals': self._identify_early_warning_signals(data)+ }++ def _recommend_bop_policies(self, data: Dict[str, Any]) -> List[str]:+ """Recommend BOP adjustment policies"""+ current_account = self.to_decimal(data.get('current_account_gdp', 0))++ if current_account < self.to_decimal(-5):+ return [+ 'Fiscal consolidation to reduce domestic absorption',+ 'Structural reforms to improve competitiveness',+ 'Exchange rate adjustment if overvalued',+ 'Capital flow management measures if needed'+ ]+ elif current_account > self.to_decimal(5):+ return [+ 'Fiscal expansion to increase domestic demand',+ 'Infrastructure investment to utilize surplus',+ 'Currency appreciation to restore balance',+ 'Gradual capital account liberalization'+ ]+ else:+ return [+ 'Maintain current policy stance',+ 'Monitor for emerging imbalances',+ 'Strengthen economic fundamentals'+ ]++ def _assess_inflow_control_effectiveness(self, data: Dict[str, Any]) -> str:+ """Assess effectiveness of capital inflow controls"""+ control_intensity = data.get('inflow_control_index', 0.5)++ if control_intensity > 0.7:+ return 'Comprehensive controls - moderately effective but may reduce efficiency'+ elif control_intensity > 0.3:+ return 'Selective controls - limited effectiveness, some circumvention'+ else:+ return 'Minimal controls - market-based allocation but potential volatility'++ def _assess_outflow_control_effectiveness(self, data: Dict[str, Any]) -> str:+ """Assess effectiveness of capital outflow controls"""+ control_intensity = data.get('outflow_control_index', 0.5)++ if control_intensity > 0.7:+ return 'Strict controls - effective short-term but high economic costs'+ elif control_intensity > 0.3:+ return 'Moderate controls - some effectiveness with manageable costs'+ else:+ return 'Light controls - limited effectiveness but preserves market efficiency'++ def _analyze_restriction_costs_benefits(self) -> Dict[str, Dict[str, List[str]]]:+ """Analyze costs and benefits of capital restrictions"""+ return {+ 'benefits': {+ 'macroeconomic': ['Exchange rate stability', 'Monetary policy independence', 'Reduced volatility'],+ 'financial': ['Reduced systemic risk', 'Prevented asset bubbles', 'Banking stability'],+ 'developmental': ['Capital allocated to development priorities', 'Reduced inequality']+ },+ 'costs': {+ 'efficiency': ['Reduced capital allocation efficiency', 'Higher cost of capital',+ 'Innovation constraints'],+ 'market_development': ['Slower financial market development', 'Reduced competition',+ 'Limited diversification'],+ 'administrative': ['High enforcement costs', 'Bureaucratic burden', 'Corruption risks']+ }+ }++ def _recommend_optimal_design(self) -> List[str]:+ """Recommend optimal design principles for capital controls"""+ return [+ 'Targeted rather than blanket restrictions',+ 'Temporary rather than permanent measures',+ 'Price-based rather than quantity-based controls',+ 'Comprehensive coverage to prevent evasion',+ 'Regular review and adjustment of measures',+ 'Clear communication of objectives and duration'+ ]++ def _analyze_current_restriction_trends(self) -> Dict[str, str]:+ """Analyze current trends in capital restrictions"""+ return {+ 'developing_countries': 'Increased use of macroprudential measures',+ 'developed_countries': 'Generally maintain open capital accounts',+ 'crisis_response': 'Temporary restrictions during financial stress',+ 'international_coordination': 'Growing recognition of spillover effects',+ 'institutional_view': 'IMF more accepting of capital flow management'+ }++ def _assess_fdi_level(self, fdi_inflows: Decimal) -> str:+ """Assess FDI inflow level"""+ if fdi_inflows > self.to_decimal(5):+ return 'High FDI inflows indicating strong investment climate'+ elif fdi_inflows > self.to_decimal(2):+ return 'Moderate FDI inflows'+ else:+ return 'Low FDI inflows, may indicate investment barriers'++ def _assess_portfolio_vulnerability(self, flows: Decimal) -> str:+ """Assess portfolio flow vulnerability"""+ if abs(flows) > self.to_decimal(5):+ return 'High vulnerability to sudden stops'+ elif abs(flows) > self.to_decimal(2):+ return 'Moderate vulnerability'+ else:+ return 'Low vulnerability to portfolio flow reversals'++ def _assess_other_flow_stability(self, flows: Decimal) -> str:+ """Assess other investment flow stability"""+ if abs(flows) > self.to_decimal(3):+ return 'Volatile other investment flows'+ else:+ return 'Relatively stable other investment flows'++ def _assess_bop_equilibrium_status(self, ca: Decimal, ka: Decimal) -> str:+ """Assess BOP equilibrium status"""+ overall = ca + ka++ if abs(overall) < self.to_decimal(1):+ return 'Balanced position'+ elif overall > self.to_decimal(2):+ return 'Surplus position - reserve accumulation'+ else:+ return 'Deficit position - reserve depletion or borrowing'++ def _assess_reserve_implications(self, balance: Decimal) -> str:+ """Assess reserve implications of BOP position"""+ if balance > self.to_decimal(2):+ return 'Reserve accumulation, potential sterilization needs'+ elif balance < self.to_decimal(-2):+ return 'Reserve depletion, potential sustainability concerns'+ else:+ return 'Stable reserve position'++ def _assess_ca_sustainability(self, ca: Decimal) -> str:+ """Assess current account sustainability"""+ if ca < self.to_decimal(-5):+ return 'Large deficit raises sustainability concerns'+ elif ca < self.to_decimal(-3):+ return 'Moderate deficit requires monitoring'+ else:+ return 'Sustainable current account position'++ def _assess_debt_sustainability(self, debt: Decimal) -> str:+ """Assess external debt sustainability"""+ if debt > self.to_decimal(60):+ return 'High external debt raises sustainability concerns'+ elif debt > self.to_decimal(40):+ return 'Moderate external debt requires monitoring'+ else:+ return 'Manageable external debt level'++ def _identify_vulnerability_indicators(self, data: Dict[str, Any]) -> List[str]:+ """Identify BOP vulnerability indicators"""+ return [+ 'Current account deficit > 5% of GDP',+ 'Short-term external debt > reserves',+ 'High dependence on volatile capital flows',+ 'Real exchange rate overvaluation',+ 'Rapid credit growth and asset price increases'+ ]++ def _identify_early_warning_signals(self, data: Dict[str, Any]) -> List[str]:+ """Identify early warning signals of BOP crisis"""+ return [+ 'Sudden stop in capital inflows',+ 'Rapid reserve depletion',+ 'Currency under pressure',+ 'Rising sovereign risk premiums',+ 'Bank deposit outflows'+ ]++ def calculate(self, analysis_type: str = 'capital_flows', **kwargs) -> Dict[str, Any]:+ """Main capital flows calculation dispatcher"""+ analyses = {+ 'capital_flows': lambda: self.analyze_capital_flow_types(kwargs.get('flow_data', {})),+ 'bop_impact': lambda: self.analyze_balance_of_payments_impact(kwargs.get('bop_data', {})),+ 'capital_restrictions': lambda: self.assess_capital_restrictions(kwargs.get('restriction_data', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class FXMarketAnalyzer(EconomicsBase):+ """Foreign exchange market structure and functionality analysis"""++ def analyze_fx_market_structure(self, market_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze foreign exchange market functions and participants"""+ return {+ 'market_functions': {+ 'price_discovery': {+ 'description': 'Determining exchange rates through supply and demand',+ 'mechanism': 'Continuous trading by global participants',+ 'efficiency': 'Generally efficient due to high liquidity and participation',+ 'factors': ['Economic fundamentals', 'Market sentiment', 'Technical factors']+ },+ 'risk_management': {+ 'description': 'Hedging currency exposure for businesses and investors',+ 'instruments': ['Spot transactions', 'Forward contracts', 'Options', 'Swaps'],+ 'participants': 'Multinational corporations, banks, institutional investors',+ 'importance': 'Critical for international trade and investment'+ },+ 'speculation': {+ 'description': 'Profit-seeking from currency movements',+ 'participants': 'Hedge funds, proprietary traders, retail investors',+ 'impact': 'Provides liquidity but can increase volatility',+ 'regulation': 'Subject to various regulatory constraints'+ },+ 'arbitrage': {+ 'description': 'Exploiting price differences across markets',+ 'types': ['Spatial arbitrage', 'Triangular arbitrage', 'Covered interest arbitrage'],+ 'function': 'Ensures price consistency across markets',+ 'technology_role': 'High-frequency trading dominates arbitrage'+ }+ },+ 'market_participants': self._analyze_market_participants(market_data),+ 'market_structure': self._analyze_market_microstructure(market_data),+ 'trading_mechanisms': self._analyze_trading_mechanisms(),+ 'liquidity_analysis': self._analyze_market_liquidity(market_data)+ }++ def distinguish_nominal_real_rates(self, rate_data: Dict[str, Any]) -> Dict[str, Any]:+ """Distinguish between nominal and real exchange rates"""+ return {+ 'nominal_exchange_rate': {+ 'definition': 'Price of one currency in terms of another currency',+ 'example': '1 USD = 1.20 EUR (Euro per US Dollar)',+ 'characteristics': [+ 'Directly observable in markets',+ 'Used for actual transactions',+ 'Affected by monetary policy and market sentiment',+ 'Can be quoted as direct or indirect'+ ],+ 'calculation': 'Market determined through trading',+ 'current_rate': rate_data.get('nominal_rate', 'N/A')+ },+ 'real_exchange_rate': {+ 'definition': 'Nominal rate adjusted for price level differences',+ 'formula': 'Real Rate = Nominal Rate × (Foreign Price Level / Domestic Price Level)',+ 'characteristics': [+ 'Measures relative purchasing power',+ 'Indicates competitiveness',+ 'Not directly tradeable',+ 'Important for trade flows'+ ],+ 'calculation': self._calculate_real_exchange_rate(rate_data),+ 'interpretation': self._interpret_real_rate_changes(rate_data)+ },+ 'relationship_analysis': {+ 'short_run': 'Nominal and real rates can diverge significantly',+ 'long_run': 'Tend to move together due to purchasing power parity',+ 'policy_implications': 'Real rates matter more for trade competitiveness',+ 'investment_relevance': 'Both rates important for different investment decisions'+ },+ 'practical_applications': self._describe_rate_applications()+ }++ def calculate_currency_percentage_change(self, change_data: Dict[str, Any]) -> Dict[str, Any]:+ """Calculate and interpret currency percentage changes"""+ initial_rate = self.to_decimal(change_data.get('initial_rate', 1))+ final_rate = self.to_decimal(change_data.get('final_rate', 1))+ base_currency = change_data.get('base_currency', 'USD')+ quote_currency = change_data.get('quote_currency', 'EUR')+ quote_convention = change_data.get('quote_convention', 'direct')++ # Calculate percentage change+ percentage_change = ((final_rate - initial_rate) / initial_rate) * self.to_decimal(100)++ # Determine currency movement+ if quote_convention == 'direct':+ # Direct quote: domestic currency per unit of foreign currency+ # Increase means domestic currency weakening+ if percentage_change > 0:+ movement = f"{base_currency} weakened by {percentage_change:.2f}%"+ description = f"{quote_currency} appreciated against {base_currency}"+ else:+ movement = f"{base_currency} strengthened by {abs(percentage_change):.2f}%"+ description = f"{quote_currency} depreciated against {base_currency}"+ else:+ # Indirect quote: foreign currency per unit of domestic currency+ # Increase means domestic currency strengthening+ if percentage_change > 0:+ movement = f"{base_currency} strengthened by {percentage_change:.2f}%"+ description = f"{base_currency} appreciated against {quote_currency}"+ else:+ movement = f"{base_currency} weakened by {abs(percentage_change):.2f}%"+ description = f"{base_currency} depreciated against {quote_currency}"++ return {+ 'calculation_details': {+ 'initial_rate': initial_rate,+ 'final_rate': final_rate,+ 'absolute_change': final_rate - initial_rate,+ 'percentage_change': percentage_change,+ 'quote_convention': quote_convention+ },+ 'currency_movement': {+ 'summary': movement,+ 'detailed_description': description,+ 'direction': 'appreciation' if percentage_change > 0 else 'depreciation',+ 'magnitude': self._assess_change_magnitude(abs(percentage_change))+ },+ 'economic_implications': self._analyze_currency_change_implications(+ percentage_change, base_currency, quote_currency+ ),+ 'trade_impact': self._assess_trade_impact(percentage_change, quote_convention),+ 'investment_implications': self._assess_investment_implications(percentage_change)+ }++ def _analyze_market_participants(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze FX market participants"""+ return {+ 'commercial_banks': {+ 'role': 'Market makers and dealers',+ 'market_share': '~75% of daily volume',+ 'functions': ['Provide liquidity', 'Client transactions', 'Proprietary trading'],+ 'importance': 'Core of interbank market'+ },+ 'central_banks': {+ 'role': 'Policy implementation and intervention',+ 'market_share': '~5% of daily volume',+ 'functions': ['Monetary policy', 'Reserve management', 'Market intervention'],+ 'impact': 'Significant influence despite small volume'+ },+ 'institutional_investors': {+ 'role': 'Hedging and investment',+ 'market_share': '~10% of daily volume',+ 'participants': ['Pension funds', 'Mutual funds', 'Insurance companies'],+ 'motivation': 'Risk management and portfolio optimization'+ },+ 'hedge_funds': {+ 'role': 'Speculation and arbitrage',+ 'market_share': '~5% of daily volume',+ 'strategies': ['Carry trades', 'Momentum', 'Mean reversion'],+ 'impact': 'High influence on short-term volatility'+ },+ 'corporations': {+ 'role': 'Commercial hedging',+ 'market_share': '~3% of daily volume',+ 'needs': ['Trade settlement', 'Risk hedging', 'Cash management'],+ 'patterns': 'Often predictable timing'+ },+ 'retail_traders': {+ 'role': 'Small-scale speculation',+ 'market_share': '~2% of daily volume',+ 'access': 'Through brokers and online platforms',+ 'characteristics': 'High leverage, short-term focus'+ }+ }++ def _analyze_market_microstructure(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze FX market microstructure"""+ return {+ 'market_type': 'Over-the-counter (OTC) decentralized market',+ 'trading_hours': '24 hours, 5 days a week across global time zones',+ 'major_centers': ['London (43%)', 'New York (17%)', 'Singapore (8%)', 'Tokyo (7%)'],+ 'market_size': data.get('daily_volume', '$7.5 trillion daily volume'),+ 'concentration': 'Top 10 banks account for ~75% of volume',+ 'electronic_trading': '~95% of transactions are electronic',+ 'settlement': 'T+2 standard settlement cycle'+ }++ def _analyze_trading_mechanisms(self) -> Dict[str, Any]:+ """Analyze FX trading mechanisms"""+ return {+ 'spot_market': {+ 'definition': 'Immediate delivery (T+2 settlement)',+ 'characteristics': 'Highest liquidity, benchmark for other rates',+ 'participants': 'All market participants',+ 'pricing': 'Continuous price discovery'+ },+ 'forward_market': {+ 'definition': 'Future delivery at predetermined rate',+ 'characteristics': 'Customizable terms, no upfront payment',+ 'participants': 'Banks, corporations, institutional investors',+ 'pricing': 'Based on interest rate differentials'+ },+ 'futures_market': {+ 'definition': 'Standardized forward contracts on exchanges',+ 'characteristics': 'Margin requirements, daily mark-to-market',+ 'participants': 'Speculators, hedgers, arbitrageurs',+ 'pricing': 'Exchange-determined, transparent'+ },+ 'options_market': {+ 'definition': 'Right but not obligation to exchange currencies',+ 'characteristics': 'Premium payment, asymmetric payoff',+ 'participants': 'Sophisticated institutional investors',+ 'pricing': 'Based on volatility and time value'+ },+ 'swap_market': {+ 'definition': 'Combination of spot and forward transactions',+ 'characteristics': 'Manages liquidity without FX risk',+ 'participants': 'Central banks, commercial banks',+ 'pricing': 'Interest rate differential based'+ }+ }++ def _analyze_market_liquidity(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze FX market liquidity"""+ return {+ 'liquidity_measures': {+ 'bid_ask_spreads': data.get('avg_spread_bps', '1-3 basis points for major pairs'),+ 'market_depth': 'High depth due to large participant base',+ 'resilience': 'Quick recovery from temporary imbalances',+ 'immediacy': 'Instant execution for standard sizes'+ },+ 'liquidity_hierarchy': {+ 'tier_1': 'EUR/USD, USD/JPY, GBP/USD (most liquid)',+ 'tier_2': 'USD/CHF, AUD/USD, USD/CAD',+ 'tier_3': 'Cross rates between major currencies',+ 'tier_4': 'Emerging market currencies (lower liquidity)'+ },+ 'factors_affecting_liquidity': [+ 'Time of day (overlap of major centers)',+ 'Economic news and events',+ 'Market volatility and uncertainty',+ 'Regulatory changes',+ 'Central bank interventions'+ ],+ 'liquidity_risk': {+ 'normal_times': 'Minimal liquidity risk for major pairs',+ 'stress_periods': 'Can experience temporary liquidity shortages',+ 'emerging_markets': 'Higher liquidity risk, especially during crises'+ }+ }++ def _calculate_real_exchange_rate(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Calculate real exchange rate"""+ nominal_rate = self.to_decimal(data.get('nominal_rate', 1))+ domestic_cpi = self.to_decimal(data.get('domestic_price_level', 100))+ foreign_cpi = self.to_decimal(data.get('foreign_price_level', 100))++ real_rate = nominal_rate * (foreign_cpi / domestic_cpi)++ return {+ 'real_exchange_rate': real_rate,+ 'calculation': f"{nominal_rate} × ({foreign_cpi}/{domestic_cpi}) = {real_rate}",+ 'interpretation': self._interpret_real_rate_level(real_rate, data.get('historical_average', 1))+ }++ def _interpret_real_rate_changes(self, data: Dict[str, Any]) -> str:+ """Interpret real exchange rate changes"""+ real_rate_change = self.to_decimal(data.get('real_rate_change_percent', 0))++ if real_rate_change > self.to_decimal(5):+ return 'Significant real appreciation - loss of competitiveness'+ elif real_rate_change < self.to_decimal(-5):+ return 'Significant real depreciation - gain in competitiveness'+ else:+ return 'Moderate real exchange rate change'++ def _interpret_real_rate_level(self, current_rate: Decimal, historical_avg: float) -> str:+ """Interpret real exchange rate level"""+ historical = self.to_decimal(historical_avg)+ deviation = ((current_rate - historical) / historical) * self.to_decimal(100)++ if deviation > self.to_decimal(10):+ return 'Real exchange rate appears overvalued'+ elif deviation < self.to_decimal(-10):+ return 'Real exchange rate appears undervalued'+ else:+ return 'Real exchange rate near historical average'++ def _describe_rate_applications(self) -> Dict[str, str]:+ """Describe practical applications of nominal vs real rates"""+ return {+ 'nominal_rates': 'Used for actual currency transactions, hedging, and short-term speculation',+ 'real_rates': 'Used for competitiveness analysis, long-term investment decisions, and trade policy',+ 'portfolio_management': 'Nominal rates for immediate hedging, real rates for strategic allocation',+ 'trade_analysis': 'Real rates better predict trade flow changes over time',+ 'central_bank_policy': 'Both rates considered, real rates for competitiveness assessment'+ }++ def _assess_change_magnitude(self, abs_change: Decimal) -> str:+ """Assess magnitude of currency change"""+ if abs_change > self.to_decimal(10):+ return 'Major currency movement'+ elif abs_change > self.to_decimal(5):+ return 'Significant currency movement'+ elif abs_change > self.to_decimal(2):+ return 'Moderate currency movement'+ else:+ return 'Minor currency movement'++ def _analyze_currency_change_implications(self, change: Decimal, base: str, quote: str) -> Dict[str, str]:+ """Analyze economic implications of currency changes"""+ return {+ 'trade_balance': 'Depreciation improves trade balance over time (J-curve effect)',+ 'inflation': 'Depreciation can increase import price inflation',+ 'competitiveness': 'Depreciation improves export competitiveness',+ 'debt_burden': 'Depreciation increases foreign currency debt burden',+ 'tourism': 'Depreciation makes country more attractive to foreign tourists',+ 'investment_flows': 'Large changes may trigger capital flow reversals'+ }++ def _assess_trade_impact(self, change: Decimal, convention: str) -> str:+ """Assess trade impact of currency change"""+ if convention == 'direct':+ if change > self.to_decimal(5):+ return 'Currency weakness should improve trade balance over 12-18 months'+ elif change < self.to_decimal(-5):+ return 'Currency strength may worsen trade balance'+ else:+ return 'Limited impact on trade balance expected'+ else:+ if change > self.to_decimal(5):+ return 'Currency strength may worsen trade balance'+ elif change < self.to_decimal(-5):+ return 'Currency weakness should improve trade balance over 12-18 months'+ else:+ return 'Limited impact on trade balance expected'++ def _assess_investment_implications(self, change: Decimal) -> List[str]:+ """Assess investment implications of currency changes"""+ implications = []++ if abs(change) > self.to_decimal(5):+ implications.extend([+ 'Significant impact on foreign investment returns',+ 'May trigger portfolio rebalancing by international investors',+ 'Hedging strategies should be reviewed'+ ])++ if change > self.to_decimal(10):+ implications.append('Large appreciation may deter foreign direct investment')+ elif change < self.to_decimal(-10):+ implications.append('Large depreciation may attract foreign direct investment')++ return implications++ def calculate(self, analysis_type: str = 'market_structure', **kwargs) -> Dict[str, Any]:+ """Main FX market calculation dispatcher"""+ analyses = {+ 'market_structure': lambda: self.analyze_fx_market_structure(kwargs.get('market_data', {})),+ 'nominal_real_rates': lambda: self.distinguish_nominal_real_rates(kwargs.get('rate_data', {})),+ 'percentage_change': lambda: self.calculate_currency_percentage_change(kwargs.get('change_data', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class ExchangeRegimeAnalyzer(EconomicsBase):+ """Exchange rate regime analysis and policy implications"""++ def analyze_exchange_rate_regimes(self, regime_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze different exchange rate regimes and their effects"""+ return {+ 'fixed_exchange_rate': {+ 'definition': 'Currency pegged to another currency or basket',+ 'characteristics': [+ 'Minimal exchange rate volatility',+ 'Requires central bank intervention',+ 'Limited monetary policy independence',+ 'Vulnerable to speculative attacks'+ ],+ 'advantages': [+ 'Reduces transaction costs for trade',+ 'Provides nominal anchor for inflation',+ 'Reduces exchange rate uncertainty',+ 'Facilitates international investment'+ ],+ 'disadvantages': [+ 'Loss of monetary policy independence',+ 'Requires large foreign exchange reserves',+ 'Vulnerable to balance of payments crises',+ 'May lead to real exchange rate misalignment'+ ],+ 'examples': ['Hong Kong Dollar', 'Danish Krone', 'Gulf States'],+ 'sustainability_factors': self._assess_fixed_regime_sustainability(regime_data)+ },+ 'floating_exchange_rate': {+ 'definition': 'Currency value determined by market forces',+ 'characteristics': [+ 'High exchange rate volatility',+ 'Automatic adjustment mechanism',+ 'Full monetary policy independence',+ 'Requires developed financial markets'+ ],+ 'advantages': [+ 'Monetary policy independence',+ 'Automatic adjustment to shocks',+ 'No need for large reserves',+ 'Reduces moral hazard in lending'+ ],+ 'disadvantages': [+ 'Exchange rate volatility and uncertainty',+ 'May complicate international trade',+ 'Potential for destabilizing speculation',+ 'Pass-through to domestic prices'+ ],+ 'examples': ['US Dollar', 'Euro', 'Japanese Yen', 'British Pound'],+ 'effectiveness_factors': self._assess_floating_regime_effectiveness(regime_data)+ },+ 'managed_float': {+ 'definition': 'Market determination with occasional intervention',+ 'characteristics': [+ 'Moderate exchange rate volatility',+ 'Discretionary intervention',+ 'Some monetary policy independence',+ 'Requires judgment on intervention timing'+ ],+ 'advantages': [+ 'Balances flexibility and stability',+ 'Allows gradual adjustment',+ 'Retains some policy independence',+ 'Can prevent excessive volatility'+ ],+ 'disadvantages': [+ 'Uncertainty about intervention policy',+ 'May delay necessary adjustments',+ 'Requires significant expertise',+ 'Potential for policy mistakes'+ ],+ 'examples': ['Chinese Yuan', 'Indian Rupee', 'Brazilian Real'],+ 'success_factors': self._identify_managed_float_success_factors()+ },+ 'currency_union': {+ 'definition': 'Countries share common currency',+ 'characteristics': [+ 'No exchange rate within union',+ 'Common monetary policy',+ 'Requires fiscal coordination',+ 'Irreversible commitment'+ ],+ 'advantages': [+ 'Eliminates exchange rate risk within union',+ 'Reduces transaction costs',+ 'Promotes trade and investment',+ 'Provides credible commitment'+ ],+ 'disadvantages': [+ 'Loss of national monetary policy',+ 'Asymmetric shock vulnerability',+ 'Requires fiscal transfers or flexibility',+ 'Difficult exit mechanism'+ ],+ 'examples': ['Eurozone', 'West African CFA Franc'],+ 'optimum_currency_area_criteria': self._assess_oca_criteria(regime_data)+ },+ 'regime_choice_factors': self._analyze_regime_choice_factors(),+ 'trade_capital_flow_effects': self._analyze_regime_effects_on_flows(regime_data)+ }++ def _assess_fixed_regime_sustainability(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess sustainability factors for fixed exchange rate regime"""+ return {+ 'foreign_reserves': {+ 'level': data.get('reserves_months_imports', 'N/A'),+ 'adequacy': 'Should cover 3-6 months of imports',+ 'assessment': self._assess_reserve_adequacy(data.get('reserves_months_imports', 3))+ },+ 'fiscal_position': {+ 'deficit': data.get('fiscal_deficit_gdp', 'N/A'),+ 'debt': data.get('government_debt_gdp', 'N/A'),+ 'sustainability': 'Fiscal discipline critical for credibility'+ },+ 'current_account': {+ 'balance': data.get('current_account_gdp', 'N/A'),+ 'sustainability': 'Large deficits threaten sustainability'+ },+ 'political_commitment': {+ 'importance': 'Strong political will essential',+ 'indicators': ['Central bank independence', 'Policy consistency', 'Reform commitment']+ }+ }++ def _assess_floating_regime_effectiveness(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess effectiveness factors for floating exchange rate regime"""+ return {+ 'financial_market_development': {+ 'depth': data.get('financial_market_depth_index', 'N/A'),+ 'importance': 'Deep markets reduce volatility',+ 'requirements': ['Large participant base', 'Diverse instruments', 'Good regulation']+ },+ 'institutional_quality': {+ 'central_bank_credibility': data.get('cb_credibility_index', 'N/A'),+ 'importance': 'Credible monetary policy anchors expectations',+ 'factors': ['Independence', 'Transparency', 'Track record']+ },+ 'pass_through_management': {+ 'inflation_targeting': 'Helps manage pass-through effects',+ 'communication': 'Clear policy communication important',+ 'credibility': 'Credible commitment to low inflation'+ }+ }++ def _identify_managed_float_success_factors(self) -> List[str]:+ """Identify success factors for managed float regimes"""+ return [+ 'Clear intervention objectives and communication',+ 'Adequate foreign exchange reserves',+ 'Flexible fiscal and monetary policies',+ 'Well-developed financial markets',+ 'Strong institutional capacity',+ 'Appropriate intervention timing and scale'+ ]++ def _assess_oca_criteria(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess optimum currency area criteria"""+ return {+ 'labor_mobility': {+ 'assessment': data.get('labor_mobility_index', 'Low'),+ 'importance': 'High mobility helps adjustment to asymmetric shocks',+ 'barriers': ['Language differences', 'Cultural factors', 'Regulatory barriers']+ },+ 'trade_integration': {+ 'level': data.get('intra_union_trade_share', 'N/A'),+ 'importance': 'High trade integration reduces asymmetric shocks',+ 'measurement': 'Share of trade within currency union'+ },+ 'business_cycle_synchronization': {+ 'correlation': data.get('business_cycle_correlation', 'N/A'),+ 'importance': 'Synchronized cycles reduce need for independent policy',+ 'factors': ['Similar economic structures', 'Common shocks', 'Policy coordination']+ },+ 'fiscal_transfers': {+ 'mechanism': data.get('fiscal_transfer_mechanism', 'Limited'),+ 'importance': 'Transfers help adjustment to asymmetric shocks',+ 'examples': ['Federal systems', 'EU structural funds', 'Automatic stabilizers']+ },+ 'price_wage_flexibility': {+ 'level': data.get('price_wage_flexibility_index', 'N/A'),+ 'importance': 'Flexibility substitutes for exchange rate adjustment',+ 'barriers': ['Labor market rigidities', 'Price stickiness', 'Regulatory constraints']+ }+ }++ def _analyze_regime_choice_factors(self) -> Dict[str, List[str]]:+ """Analyze factors influencing exchange rate regime choice"""+ return {+ 'economic_factors': [+ 'Size and openness of economy',+ 'Trade pattern and partner concentration',+ 'Financial market development',+ 'Inflation history and credibility',+ 'Fiscal position and discipline'+ ],+ 'institutional_factors': [+ 'Central bank independence and credibility',+ 'Political stability and consensus',+ 'Administrative capacity',+ 'Legal and regulatory framework',+ 'International integration'+ ],+ 'external_factors': [+ 'International capital mobility',+ 'Regional integration arrangements',+ 'Major trading partner regimes',+ 'Global financial conditions',+ 'International monetary system'+ ]+ }++ def _analyze_regime_effects_on_flows(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze effects of exchange rate regimes on trade and capital flows"""+ return {+ 'trade_effects': {+ 'fixed_regime': {+ 'trade_volume': 'Generally higher due to reduced uncertainty',+ 'trade_composition': 'May favor short-term over long-term contracts',+ 'price_competitiveness': 'May lead to misalignment over time'+ },+ 'floating_regime': {+ 'trade_volume': 'May be lower due to exchange rate risk',+ 'trade_composition': 'Encourages hedging and risk management',+ 'price_competitiveness': 'Maintains competitiveness through adjustment'+ }+ },+ 'capital_flow_effects': {+ 'fixed_regime': {+ 'portfolio_flows': 'May attract flows but vulnerable to sudden stops',+ 'fdi_flows': 'Reduced exchange rate risk may encourage FDI',+ 'speculative_flows': 'Vulnerable to one-way bets against the peg'+ },+ 'floating_regime': {+ 'portfolio_flows': 'More volatile but self-correcting',+ 'fdi_flows': 'Exchange rate risk may deter some investment',+ 'speculative_flows': 'Two-way risk reduces speculative pressure'+ }+ },+ 'crisis_vulnerability': {+ 'fixed_regime': 'High vulnerability to balance of payments crises',+ 'floating_regime': 'Lower crisis probability but higher volatility',+ 'managed_float': 'Intermediate vulnerability depending on credibility'+ }+ }++ def _assess_reserve_adequacy(self, months_imports: float) -> str:+ """Assess foreign reserve adequacy"""+ if months_imports >= 6:+ return 'Adequate reserves for fixed regime'+ elif months_imports >= 3:+ return 'Borderline adequate reserves'+ else:+ return 'Insufficient reserves for sustainable fixed regime'++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate exchange rate regime analysis"""+ result = self.analyze_exchange_rate_regimes(kwargs.get('regime_data', {}))+ result['metadata'] = self.get_metadata()+ return result\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/core.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/core.pynew file mode 100644index 000000000..16bb7ae4c--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/core.py@@ -0,0 +1,407 @@+"""+Economics Analytics Core Framework+==================================++Comprehensive foundation for economic analysis providing base classes, validation utilities, mathematical functions, and data containers. Implements CFA Institute standard methodologies with high-precision decimal arithmetic for reliable economic calculations.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Economic time series data (GDP, inflation, interest rates)+ - Exchange rate data and currency information+ - Balance of payments and capital flow statistics+ - Price level indices and inflation measures+ - Central bank policy data and monetary indicators+ - Trade statistics and international transaction data++OUTPUT:+ - Validated economic data containers with metadata+ - High-precision calculation results and analytics+ - Standardized economic indicators and metrics+ - Data quality assessments and validation reports+ - Mathematical calculations for economic modeling+ - Configuration settings and global constants++PARAMETERS:+ - precision: Decimal precision for calculations - default: 8+ - base_currency: Base currency for analysis - default: 'USD'+ - data_validation_enabled: Enable input validation - default: True+ - error_tolerance: Numerical error tolerance - default: 1e-6+ - default_confidence_interval: Default CI for calculations - default: 0.95+ - cache_enabled: Enable result caching - default: True+ - currency_code: ISO 4217 currency code+ - exchange_rate: Foreign exchange rate value+ - interest_rate: Annual interest rate (can be negative)+ - inflation_rate: Annual inflation rate+ - gdp_value: Gross Domestic Product value+ - time_period: Time period in years+"""++import re+import logging+from abc import ABC, abstractmethod+from decimal import Decimal, getcontext, ROUND_HALF_UP+from typing import Any, Dict, List, Optional, Union, Tuple+from datetime import datetime, date+import pandas as pd+import numpy as np++# Set high precision for financial calculations+getcontext().prec = 28++# Configure logging+logging.basicConfig(level=logging.INFO)+logger = logging.getLogger(__name__)+++class EconomicsError(Exception):+ """Base exception for economics module"""+ pass+++class ValidationError(EconomicsError):+ """Data validation errors"""+ pass+++class CalculationError(EconomicsError):+ """Mathematical calculation errors"""+ pass+++class DataError(EconomicsError):+ """Data sourcing and formatting errors"""+ pass+++class EconomicsBase(ABC):+ """+ Abstract base class for all economics analysis components.+ Ensures consistent interface and precision across modules.+ """++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ self.precision = precision+ self.base_currency = base_currency+ self.validator = DataValidator()+ self._results_cache = {}++ def to_decimal(self, value: Union[float, int, str]) -> Decimal:+ """Convert value to high-precision Decimal"""+ try:+ return Decimal(str(value)).quantize(+ Decimal('0.' + '0' * self.precision),+ rounding=ROUND_HALF_UP+ )+ except Exception as e:+ raise CalculationError(f"Cannot convert {value} to Decimal: {e}")++ def validate_inputs(self, **kwargs) -> bool:+ """Validate input parameters"""+ return self.validator.validate_parameters(**kwargs)++ @abstractmethod+ def calculate(self, *args, **kwargs) -> Dict[str, Any]:+ """Main calculation method - must be implemented by subclasses"""+ pass++ def get_metadata(self) -> Dict[str, Any]:+ """Return component metadata"""+ return {+ 'class': self.__class__.__name__,+ 'precision': self.precision,+ 'base_currency': self.base_currency,+ 'timestamp': datetime.now().isoformat()+ }+++class DataValidator:+ """+ Comprehensive data validation for economics calculations.+ Ensures data quality and CFA-compliant input standards.+ """++ def __init__(self):+ self.currency_codes = {+ 'USD', 'EUR', 'GBP', 'JPY', 'CHF', 'AUD', 'CAD', 'NZD',+ 'SEK', 'NOK', 'DKK', 'CNY', 'INR', 'BRL', 'RUB', 'ZAR',+ 'MXN', 'SGD', 'HKD', 'KRW', 'TRY', 'PLN', 'CZK', 'HUF'+ }++ def validate_currency_code(self, code: str) -> bool:+ """Validate ISO currency code"""+ if not isinstance(code, str) or len(code) != 3:+ raise ValidationError(f"Invalid currency code format: {code}")+ if code.upper() not in self.currency_codes:+ raise ValidationError(f"Unsupported currency code: {code}")+ return True++ def validate_exchange_rate(self, rate: Union[float, Decimal]) -> bool:+ """Validate exchange rate values"""+ rate = Decimal(str(rate)) if not isinstance(rate, Decimal) else rate+ if rate <= 0:+ raise ValidationError(f"Exchange rate must be positive: {rate}")+ if rate > Decimal('1000000'):+ raise ValidationError(f"Exchange rate seems unrealistic: {rate}")+ return True++ def validate_interest_rate(self, rate: Union[float, Decimal]) -> bool:+ """Validate interest rate (can be negative)"""+ rate = Decimal(str(rate)) if not isinstance(rate, Decimal) else rate+ if rate < Decimal('-0.10') or rate > Decimal('1.0'):+ raise ValidationError(f"Interest rate outside reasonable range: {rate}")+ return True++ def validate_time_period(self, period: Union[int, float]) -> bool:+ """Validate time periods in years"""+ if not isinstance(period, (int, float)) or period <= 0:+ raise ValidationError(f"Time period must be positive: {period}")+ if period > 100:+ raise ValidationError(f"Time period seems unrealistic: {period}")+ return True++ def validate_gdp_data(self, gdp: Union[float, Decimal]) -> bool:+ """Validate GDP values"""+ gdp = Decimal(str(gdp)) if not isinstance(gdp, Decimal) else gdp+ if gdp <= 0:+ raise ValidationError(f"GDP must be positive: {gdp}")+ return True++ def validate_inflation_rate(self, rate: Union[float, Decimal]) -> bool:+ """Validate inflation rates"""+ rate = Decimal(str(rate)) if not isinstance(rate, Decimal) else rate+ if rate < Decimal('-0.5') or rate > Decimal('2.0'):+ raise ValidationError(f"Inflation rate outside normal range: {rate}")+ return True++ def validate_date_format(self, date_input: Union[str, datetime, date]) -> datetime:+ """Validate and convert date inputs"""+ if isinstance(date_input, datetime):+ return date_input+ elif isinstance(date_input, date):+ return datetime.combine(date_input, datetime.min.time())+ elif isinstance(date_input, str):+ try:+ return datetime.strptime(date_input, '%Y-%m-%d')+ except ValueError:+ try:+ return datetime.strptime(date_input, '%Y/%m/%d')+ except ValueError:+ raise ValidationError(f"Invalid date format: {date_input}")+ else:+ raise ValidationError(f"Unsupported date type: {type(date_input)}")++ def validate_percentage(self, value: Union[float, Decimal]) -> bool:+ """Validate percentage values (0-100 or 0-1)"""+ value = Decimal(str(value)) if not isinstance(value, Decimal) else value+ if value < 0 or value > 100:+ raise ValidationError(f"Percentage outside valid range: {value}")+ return True++ def validate_dataframe(self, df: pd.DataFrame, required_columns: List[str]) -> bool:+ """Validate pandas DataFrame structure"""+ if not isinstance(df, pd.DataFrame):+ raise ValidationError("Input must be a pandas DataFrame")++ missing_cols = set(required_columns) - set(df.columns)+ if missing_cols:+ raise ValidationError(f"Missing required columns: {missing_cols}")++ if df.empty:+ raise ValidationError("DataFrame cannot be empty")++ return True++ def validate_bid_ask_spread(self, bid: Decimal, ask: Decimal) -> bool:+ """Validate bid-ask spread"""+ if bid >= ask:+ raise ValidationError(f"Bid ({bid}) must be less than ask ({ask})")++ spread = (ask - bid) / bid+ if spread > Decimal('0.1'): # 10% spread seems excessive+ raise ValidationError(f"Bid-ask spread too wide: {spread:.4f}")++ return True++ def validate_parameters(self, **kwargs) -> bool:+ """Validate multiple parameters based on their types"""+ validators = {+ 'currency': self.validate_currency_code,+ 'exchange_rate': self.validate_exchange_rate,+ 'interest_rate': self.validate_interest_rate,+ 'time_period': self.validate_time_period,+ 'gdp': self.validate_gdp_data,+ 'inflation': self.validate_inflation_rate,+ 'percentage': self.validate_percentage,+ 'date': self.validate_date_format+ }++ for param_name, param_value in kwargs.items():+ # Extract parameter type from name+ param_type = None+ for validator_type in validators.keys():+ if validator_type in param_name.lower():+ param_type = validator_type+ break++ if param_type and param_value is not None:+ validators[param_type](param_value)++ return True+++class CalculationUtils:+ """+ Utility functions for common economic calculations.+ Provides mathematical precision and error handling.+ """++ @staticmethod+ def compound_growth_rate(initial: Decimal, final: Decimal, periods: Decimal) -> Decimal:+ """Calculate compound annual growth rate"""+ if initial <= 0 or final <= 0 or periods <= 0:+ raise CalculationError("All values must be positive for CAGR calculation")++ return (final / initial) ** (Decimal('1') / periods) - Decimal('1')++ @staticmethod+ def present_value(future_value: Decimal, rate: Decimal, periods: Decimal) -> Decimal:+ """Calculate present value"""+ if periods <= 0:+ raise CalculationError("Periods must be positive")++ return future_value / ((Decimal('1') + rate) ** periods)++ @staticmethod+ def future_value(present_value: Decimal, rate: Decimal, periods: Decimal) -> Decimal:+ """Calculate future value"""+ if periods <= 0:+ raise CalculationError("Periods must be positive")++ return present_value * ((Decimal('1') + rate) ** periods)++ @staticmethod+ def effective_rate(nominal_rate: Decimal, compounding_frequency: int) -> Decimal:+ """Calculate effective annual rate"""+ if compounding_frequency <= 0:+ raise CalculationError("Compounding frequency must be positive")++ return (Decimal('1') + nominal_rate / Decimal(str(compounding_frequency))) ** Decimal(+ str(compounding_frequency)) - Decimal('1')++ @staticmethod+ def geometric_mean(values: List[Decimal]) -> Decimal:+ """Calculate geometric mean"""+ if not values or any(v <= 0 for v in values):+ raise CalculationError("All values must be positive for geometric mean")++ product = Decimal('1')+ for value in values:+ product *= value++ return product ** (Decimal('1') / Decimal(str(len(values))))++ @staticmethod+ def standard_deviation(values: List[Decimal]) -> Decimal:+ """Calculate sample standard deviation"""+ if len(values) < 2:+ raise CalculationError("At least 2 values required for standard deviation")++ mean = sum(values) / Decimal(str(len(values)))+ variance = sum((x - mean) ** 2 for x in values) / Decimal(str(len(values) - 1))++ return variance.sqrt()+++class DataContainer:+ """+ Container for economic data with validation and metadata.+ Ensures data integrity throughout calculations.+ """++ def __init__(self, data: Dict[str, Any], data_type: str, timestamp: Optional[datetime] = None):+ self.data = data+ self.data_type = data_type+ self.timestamp = timestamp or datetime.now()+ self.validator = DataValidator()+ self._validate_data()++ def _validate_data(self):+ """Validate data based on type"""+ validation_rules = {+ 'currency': ['currency_code', 'exchange_rate'],+ 'gdp': ['gdp_value', 'country_code'],+ 'interest_rate': ['rate_value', 'currency'],+ 'inflation': ['inflation_rate', 'period']+ }++ if self.data_type in validation_rules:+ required_fields = validation_rules[self.data_type]+ for field in required_fields:+ if field not in self.data:+ raise ValidationError(f"Missing required field for {self.data_type}: {field}")++ def get_value(self, key: str, default: Any = None) -> Any:+ """Get value with optional default"""+ return self.data.get(key, default)++ def update_value(self, key: str, value: Any):+ """Update value with validation"""+ self.data[key] = value+ self._validate_data()++ def to_dict(self) -> Dict[str, Any]:+ """Convert to dictionary with metadata"""+ return {+ 'data': self.data,+ 'type': self.data_type,+ 'timestamp': self.timestamp.isoformat(),+ 'validated': True+ }+++# Global configuration+class EconomicsConfig:+ """Global configuration for economics module"""++ def __init__(self):+ self.precision = 8+ self.base_currency = 'USD'+ self.data_validation_enabled = True+ self.error_tolerance = Decimal('1e-6')+ self.default_confidence_interval = Decimal('0.95')+ self.cache_enabled = True+ self.logging_level = logging.INFO++ def update_config(self, **kwargs):+ """Update configuration parameters"""+ for key, value in kwargs.items():+ if hasattr(self, key):+ setattr(self, key, value)+ else:+ logger.warning(f"Unknown configuration parameter: {key}")++ def to_dict(self) -> Dict[str, Any]:+ """Convert configuration to dictionary"""+ return {+ 'precision': self.precision,+ 'base_currency': self.base_currency,+ 'data_validation_enabled': self.data_validation_enabled,+ 'error_tolerance': str(self.error_tolerance),+ 'default_confidence_interval': str(self.default_confidence_interval),+ 'cache_enabled': self.cache_enabled,+ 'logging_level': self.logging_level+ }+++# Module constants+ECONOMIC_CONSTANTS = {+ 'DAYS_PER_YEAR': Decimal('365'),+ 'BUSINESS_DAYS_PER_YEAR': Decimal('252'),+ 'MONTHS_PER_YEAR': Decimal('12'),+ 'QUARTERS_PER_YEAR': Decimal('4'),+ 'BASIS_POINTS': Decimal('10000'),+ 'PERCENTAGE': Decimal('100')+}++# Export global configuration instance+config = EconomicsConfig()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/currency_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/currency_analysis.pynew file mode 100644index 000000000..f4dab40f3--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/currency_analysis.py@@ -0,0 +1,568 @@+"""+Currency Exchange Rate Analytics Module+======================================++Comprehensive currency analysis implementing CFA Institute Level II curriculum for exchange rates, arbitrage, parity conditions, and carry trades. Provides advanced foreign exchange analytics with precision calculations and risk assessments.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Real-time FX market data (spot, forward, bid/ask rates)+ - Currency pair quotes and market depth information+ - Interest rate data for carry trade calculations+ - Inflation and price level data for PPP analysis+ - Balance of payments and current account data+ - Central bank policy and intervention data+ - Market volatility and liquidity indicators++OUTPUT:+ - Bid-offer spread analysis and impact assessments+ - Triangular arbitrage opportunity detection and profit calculations+ - Forward premium/discount calculations and mark-to-market valuations+ - International parity condition testing and violation analysis+ - Carry trade return calculations and risk assessments+ - Long-run fair value assessments and currency misalignment indicators+ - Currency crisis warning signals and vulnerability assessments++PARAMETERS:+ - bid: Bid price for currency pair+ - ask: Ask price for currency pair+ - spot_rate: Current spot exchange rate+ - forward_rate: Forward exchange rate for specific maturity+ - time_to_maturity: Time to forward contract maturity in years+ - domestic_rate: Domestic interest rate+ - foreign_rate: Foreign interest rate+ - domestic_inflation: Domestic inflation rate+ - foreign_inflation: Foreign inflation rate+ - leverage: Leverage factor for carry trades+ - investment_amount: Investment amount for arbitrage calculations+ - currency_quotes: Dictionary of currency pair bid/ask quotes+ - market_conditions: Market volatility and volume data+"""++from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any+from datetime import datetime, timedelta+import pandas as pd+import numpy as np+from .core import EconomicsBase, ValidationError, CalculationError, DataError+++class CurrencyAnalyzer(EconomicsBase):+ """Main currency analysis coordinator"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)+ self.spot_forward = SpotForwardAnalyzer(precision, base_currency)+ self.arbitrage = ArbitrageDetector(precision, base_currency)+ self.parity = ParityAnalyzer(precision, base_currency)+ self.carry_trade = CarryTradeAnalyzer(precision, base_currency)++ def calculate(self, analysis_type: str, **kwargs) -> Dict[str, Any]:+ """Route calculation to appropriate analyzer"""+ analyzers = {+ 'spot_forward': self.spot_forward.calculate,+ 'arbitrage': self.arbitrage.calculate,+ 'parity': self.parity.calculate,+ 'carry_trade': self.carry_trade.calculate+ }++ if analysis_type not in analyzers:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ return analyzers[analysis_type](**kwargs)+++class SpotForwardAnalyzer(EconomicsBase):+ """Spot and forward rate analysis with bid-offer spreads"""++ def calculate_bid_offer_spread(self, bid: Decimal, ask: Decimal) -> Dict[str, Decimal]:+ """Calculate bid-offer spread metrics"""+ self.validator.validate_bid_ask_spread(bid, ask)++ spread_points = ask - bid+ spread_percentage = (spread_points / bid) * self.to_decimal(100)+ mid_rate = (bid + ask) / self.to_decimal(2)++ return {+ 'bid': bid,+ 'ask': ask,+ 'mid_rate': mid_rate,+ 'spread_points': spread_points,+ 'spread_percentage': spread_percentage,+ 'spread_basis_points': spread_percentage * self.to_decimal(100)+ }++ def factors_affecting_spread(self, currency_pair: str, market_conditions: Dict[str, Any]) -> Dict[str, str]:+ """Analyze factors affecting bid-offer spread"""+ factors = {+ 'trading_volume': 'Higher volume = narrower spreads',+ 'market_volatility': 'Higher volatility = wider spreads',+ 'time_of_day': 'Active trading hours = narrower spreads',+ 'liquidity': 'More liquid pairs = narrower spreads',+ 'political_stability': 'Less stable = wider spreads',+ 'central_bank_intervention': 'Active intervention = wider spreads'+ }++ assessment = {}+ volume = market_conditions.get('daily_volume', 0)+ volatility = market_conditions.get('volatility', 0)++ if volume > 1000000: # High volume+ assessment['volume_impact'] = 'Narrow spread expected'+ else:+ assessment['volume_impact'] = 'Wide spread expected'++ if volatility > 0.02: # High volatility (2%+)+ assessment['volatility_impact'] = 'Wide spread expected'+ else:+ assessment['volatility_impact'] = 'Narrow spread expected'++ assessment.update(factors)+ return assessment++ def calculate_forward_premium_discount(self, spot_rate: Decimal, forward_rate: Decimal,+ time_to_maturity: Decimal) -> Dict[str, Decimal]:+ """Calculate forward premium/discount"""+ self.validator.validate_exchange_rate(spot_rate)+ self.validator.validate_exchange_rate(forward_rate)+ self.validator.validate_time_period(time_to_maturity)++ # Annualized premium/discount+ premium_discount = ((forward_rate - spot_rate) / spot_rate) * (self.to_decimal(1) / time_to_maturity)+ premium_discount_percent = premium_discount * self.to_decimal(100)++ return {+ 'spot_rate': spot_rate,+ 'forward_rate': forward_rate,+ 'time_to_maturity': time_to_maturity,+ 'premium_discount': premium_discount,+ 'premium_discount_percent': premium_discount_percent,+ 'is_premium': forward_rate > spot_rate,+ 'annualized_rate': premium_discount_percent+ }++ def mark_to_market_forward(self, contract_details: Dict[str, Any], current_market_data: Dict[str, Any]) -> Dict[+ str, Decimal]:+ """Calculate mark-to-market value of forward contract"""+ # Contract details+ notional = self.to_decimal(contract_details['notional_amount'])+ contract_rate = self.to_decimal(contract_details['contract_rate'])+ maturity = self.to_decimal(contract_details['time_to_maturity'])+ position = contract_details['position'] # 'long' or 'short'++ # Current market data+ current_forward = self.to_decimal(current_market_data['current_forward_rate'])+ risk_free_rate = self.to_decimal(current_market_data['risk_free_rate'])++ # Calculate present value of the difference+ rate_difference = current_forward - contract_rate+ if position == 'short':+ rate_difference = -rate_difference++ # Present value of gain/loss+ pv_factor = self.to_decimal(1) / ((self.to_decimal(1) + risk_free_rate) ** maturity)+ mtm_value = notional * rate_difference * pv_factor++ return {+ 'mtm_value': mtm_value,+ 'notional_amount': notional,+ 'contract_rate': contract_rate,+ 'current_forward_rate': current_forward,+ 'rate_difference': rate_difference,+ 'position': position,+ 'pv_factor': pv_factor,+ 'unrealized_pnl': mtm_value+ }++ def calculate(self, calculation_type: str, **kwargs) -> Dict[str, Any]:+ """Main calculation dispatcher"""+ calculations = {+ 'bid_offer_spread': lambda: self.calculate_bid_offer_spread(+ self.to_decimal(kwargs['bid']), self.to_decimal(kwargs['ask'])+ ),+ 'forward_premium_discount': lambda: self.calculate_forward_premium_discount(+ self.to_decimal(kwargs['spot_rate']),+ self.to_decimal(kwargs['forward_rate']),+ self.to_decimal(kwargs['time_to_maturity'])+ ),+ 'mark_to_market': lambda: self.mark_to_market_forward(+ kwargs['contract_details'], kwargs['current_market_data']+ ),+ 'spread_factors': lambda: self.factors_affecting_spread(+ kwargs['currency_pair'], kwargs['market_conditions']+ )+ }++ if calculation_type not in calculations:+ raise ValidationError(f"Unknown calculation type: {calculation_type}")++ result = calculations[calculation_type]()+ result['metadata'] = self.get_metadata()+ result['calculation_type'] = calculation_type++ return result+++class ArbitrageDetector(EconomicsBase):+ """Triangular arbitrage detection and profit calculation"""++ def detect_triangular_arbitrage(self, currency_quotes: Dict[str, Dict[str, Decimal]],+ base_currency: str = None) -> Dict[str, Any]:+ """Detect triangular arbitrage opportunities"""+ base = base_currency or self.base_currency++ opportunities = []+ currencies = list(currency_quotes.keys())++ # Check all possible triangular combinations+ for i, curr1 in enumerate(currencies):+ for j, curr2 in enumerate(currencies[i + 1:], i + 1):+ for k, curr3 in enumerate(currencies[j + 1:], j + 1):+ # Check triangular arbitrage for this combination+ opportunity = self._check_triangle(curr1, curr2, curr3, currency_quotes)+ if opportunity['arbitrage_exists']:+ opportunities.append(opportunity)++ return {+ 'opportunities': opportunities,+ 'total_opportunities': len(opportunities),+ 'base_currency': base,+ 'quotes_analyzed': len(currencies),+ 'timestamp': datetime.now().isoformat()+ }++ def _check_triangle(self, curr1: str, curr2: str, curr3: str,+ quotes: Dict[str, Dict[str, Decimal]]) -> Dict[str, Any]:+ """Check specific triangular arbitrage opportunity"""+ try:+ # Get bid/ask rates for all pairs+ pair1 = f"{curr1}/{curr2}"+ pair2 = f"{curr2}/{curr3}"+ pair3 = f"{curr3}/{curr1}"++ # Forward path: curr1 -> curr2 -> curr3 -> curr1+ if pair1 in quotes and pair2 in quotes and pair3 in quotes:+ rate1 = quotes[pair1]['ask'] # Buy curr2 with curr1+ rate2 = quotes[pair2]['ask'] # Buy curr3 with curr2+ rate3 = quotes[pair3]['bid'] # Sell curr1 for curr3++ forward_result = rate1 * rate2 * rate3++ # Reverse path: curr1 -> curr3 -> curr2 -> curr1+ rate1_rev = quotes[pair3]['ask'] # Buy curr3 with curr1+ rate2_rev = self.to_decimal(1) / quotes[pair2]['bid'] # Buy curr2 with curr3+ rate3_rev = self.to_decimal(1) / quotes[pair1]['bid'] # Buy curr1 with curr2++ reverse_result = rate1_rev * rate2_rev * rate3_rev++ # Check for arbitrage+ arbitrage_forward = forward_result > self.to_decimal(1)+ arbitrage_reverse = reverse_result > self.to_decimal(1)++ if arbitrage_forward or arbitrage_reverse:+ best_path = 'forward' if forward_result > reverse_result else 'reverse'+ profit_factor = max(forward_result, reverse_result)++ return {+ 'currencies': [curr1, curr2, curr3],+ 'arbitrage_exists': True,+ 'best_path': best_path,+ 'profit_factor': profit_factor,+ 'profit_percentage': (profit_factor - self.to_decimal(1)) * self.to_decimal(100),+ 'forward_result': forward_result,+ 'reverse_result': reverse_result+ }++ return {+ 'currencies': [curr1, curr2, curr3],+ 'arbitrage_exists': False,+ 'profit_factor': self.to_decimal(0),+ 'profit_percentage': self.to_decimal(0)+ }++ except Exception as e:+ raise CalculationError(f"Error calculating triangular arbitrage: {e}")++ def calculate_arbitrage_profit(self, opportunity: Dict[str, Any],+ investment_amount: Decimal) -> Dict[str, Decimal]:+ """Calculate profit from arbitrage opportunity"""+ if not opportunity['arbitrage_exists']:+ raise ValidationError("No arbitrage opportunity exists")++ profit_factor = opportunity['profit_factor']+ gross_profit = investment_amount * (profit_factor - self.to_decimal(1))++ # Estimate transaction costs (typical 0.1% per transaction)+ transaction_cost_rate = self.to_decimal(0.001)+ num_transactions = self.to_decimal(3) # Three currency exchanges+ transaction_costs = investment_amount * transaction_cost_rate * num_transactions++ net_profit = gross_profit - transaction_costs+ net_profit_percentage = (net_profit / investment_amount) * self.to_decimal(100)++ return {+ 'investment_amount': investment_amount,+ 'gross_profit': gross_profit,+ 'transaction_costs': transaction_costs,+ 'net_profit': net_profit,+ 'net_profit_percentage': net_profit_percentage,+ 'profit_factor': profit_factor,+ 'viable': net_profit > self.to_decimal(0)+ }++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Main arbitrage calculation"""+ if 'currency_quotes' in kwargs:+ return self.detect_triangular_arbitrage(+ kwargs['currency_quotes'],+ kwargs.get('base_currency')+ )+ elif 'opportunity' in kwargs and 'investment_amount' in kwargs:+ return self.calculate_arbitrage_profit(+ kwargs['opportunity'],+ self.to_decimal(kwargs['investment_amount'])+ )+ else:+ raise ValidationError("Missing required parameters for arbitrage calculation")+++class ParityAnalyzer(EconomicsBase):+ """International parity conditions analysis"""++ def covered_interest_rate_parity(self, spot_rate: Decimal, forward_rate: Decimal,+ domestic_rate: Decimal, foreign_rate: Decimal,+ time_period: Decimal) -> Dict[str, Any]:+ """Test covered interest rate parity condition"""+ # CIP: F/S = (1 + r_domestic * t) / (1 + r_foreign * t)+ theoretical_forward = spot_rate * (+ (self.to_decimal(1) + domestic_rate * time_period) /+ (self.to_decimal(1) + foreign_rate * time_period)+ )++ deviation = forward_rate - theoretical_forward+ deviation_percentage = (deviation / theoretical_forward) * self.to_decimal(100)++ # Arbitrage opportunity exists if deviation > transaction costs+ arbitrage_threshold = self.to_decimal(0.1) # 0.1%+ arbitrage_opportunity = abs(deviation_percentage) > arbitrage_threshold++ return {+ 'spot_rate': spot_rate,+ 'forward_rate': forward_rate,+ 'theoretical_forward': theoretical_forward,+ 'deviation': deviation,+ 'deviation_percentage': deviation_percentage,+ 'parity_holds': abs(deviation_percentage) < self.to_decimal(0.05),+ 'arbitrage_opportunity': arbitrage_opportunity,+ 'domestic_rate': domestic_rate,+ 'foreign_rate': foreign_rate,+ 'time_period': time_period+ }++ def uncovered_interest_rate_parity(self, spot_rate: Decimal, expected_spot: Decimal,+ domestic_rate: Decimal, foreign_rate: Decimal,+ time_period: Decimal) -> Dict[str, Any]:+ """Test uncovered interest rate parity condition"""+ # UIP: E(S_t+1)/S_t = (1 + r_domestic * t) / (1 + r_foreign * t)+ theoretical_expected = spot_rate * (+ (self.to_decimal(1) + domestic_rate * time_period) /+ (self.to_decimal(1) + foreign_rate * time_period)+ )++ deviation = expected_spot - theoretical_expected+ deviation_percentage = (deviation / theoretical_expected) * self.to_decimal(100)++ return {+ 'spot_rate': spot_rate,+ 'expected_spot': expected_spot,+ 'theoretical_expected': theoretical_expected,+ 'deviation': deviation,+ 'deviation_percentage': deviation_percentage,+ 'parity_holds': abs(deviation_percentage) < self.to_decimal(5),+ 'risk_premium': deviation_percentage+ }++ def purchasing_power_parity(self, spot_rate: Decimal, domestic_inflation: Decimal,+ foreign_inflation: Decimal, time_period: Decimal) -> Dict[str, Any]:+ """Test purchasing power parity"""+ # PPP: S_t+1/S_t = (1 + π_domestic) / (1 + π_foreign)+ theoretical_rate = spot_rate * (+ (self.to_decimal(1) + domestic_inflation * time_period) /+ (self.to_decimal(1) + foreign_inflation * time_period)+ )++ return {+ 'current_spot': spot_rate,+ 'theoretical_rate': theoretical_rate,+ 'domestic_inflation': domestic_inflation,+ 'foreign_inflation': foreign_inflation,+ 'inflation_differential': domestic_inflation - foreign_inflation,+ 'time_period': time_period,+ 'expected_change_percentage': ((theoretical_rate - spot_rate) / spot_rate) * self.to_decimal(100)+ }++ def international_fisher_effect(self, domestic_nominal: Decimal, foreign_nominal: Decimal,+ domestic_real: Decimal, foreign_real: Decimal) -> Dict[str, Any]:+ """Test International Fisher Effect"""+ # IFE: (1 + r_nominal_domestic) / (1 + r_nominal_foreign) = (1 + r_real_domestic) / (1 + r_real_foreign)+ nominal_ratio = (self.to_decimal(1) + domestic_nominal) / (self.to_decimal(1) + foreign_nominal)+ real_ratio = (self.to_decimal(1) + domestic_real) / (self.to_decimal(1) + foreign_real)++ deviation = nominal_ratio - real_ratio+ deviation_percentage = (deviation / real_ratio) * self.to_decimal(100)++ return {+ 'domestic_nominal_rate': domestic_nominal,+ 'foreign_nominal_rate': foreign_nominal,+ 'domestic_real_rate': domestic_real,+ 'foreign_real_rate': foreign_real,+ 'nominal_ratio': nominal_ratio,+ 'real_ratio': real_ratio,+ 'deviation': deviation,+ 'deviation_percentage': deviation_percentage,+ 'fisher_effect_holds': abs(deviation_percentage) < self.to_decimal(1)+ }++ def calculate(self, parity_type: str, **kwargs) -> Dict[str, Any]:+ """Calculate specific parity condition"""+ parity_functions = {+ 'covered_interest_parity': self.covered_interest_rate_parity,+ 'uncovered_interest_parity': self.uncovered_interest_rate_parity,+ 'purchasing_power_parity': self.purchasing_power_parity,+ 'international_fisher_effect': self.international_fisher_effect+ }++ if parity_type not in parity_functions:+ raise ValidationError(f"Unknown parity type: {parity_type}")++ # Convert all numeric inputs to Decimal+ decimal_kwargs = {}+ for key, value in kwargs.items():+ if isinstance(value, (int, float, str)) and key != 'parity_type':+ try:+ decimal_kwargs[key] = self.to_decimal(value)+ except:+ decimal_kwargs[key] = value+ else:+ decimal_kwargs[key] = value++ result = parity_functions[parity_type](**decimal_kwargs)+ result['metadata'] = self.get_metadata()+ result['parity_type'] = parity_type++ return result+++class CarryTradeAnalyzer(EconomicsBase):+ """Carry trade analysis and profit calculations"""++ def calculate_carry_trade_return(self, funding_currency_rate: Decimal,+ target_currency_rate: Decimal,+ exchange_rate_change: Decimal,+ time_period: Decimal,+ leverage: Decimal = None) -> Dict[str, Any]:+ """Calculate carry trade returns"""+ leverage = leverage or self.to_decimal(1)++ # Interest rate differential+ rate_differential = target_currency_rate - funding_currency_rate++ # Interest income (annualized)+ interest_income = rate_differential * time_period++ # Exchange rate return+ fx_return = exchange_rate_change++ # Total return before leverage+ total_return = interest_income + fx_return++ # Leveraged return+ leveraged_return = total_return * leverage++ # Risk assessment+ sharpe_ratio = self._calculate_carry_trade_sharpe(+ rate_differential, exchange_rate_change, time_period+ )++ return {+ 'funding_rate': funding_currency_rate,+ 'target_rate': target_currency_rate,+ 'rate_differential': rate_differential,+ 'interest_income': interest_income,+ 'fx_return': fx_return,+ 'total_return': total_return,+ 'leverage': leverage,+ 'leveraged_return': leveraged_return,+ 'annualized_return': leveraged_return / time_period,+ 'time_period': time_period,+ 'sharpe_ratio': sharpe_ratio,+ 'risk_level': self._assess_carry_trade_risk(rate_differential, leverage)+ }++ def _calculate_carry_trade_sharpe(self, rate_diff: Decimal, fx_change: Decimal,+ time_period: Decimal) -> Decimal:+ """Simplified Sharpe ratio calculation for carry trade"""+ # Assume historical volatility of 10% for FX+ assumed_volatility = self.to_decimal(0.10)++ expected_return = rate_diff * time_period+ risk_free_rate = self.to_decimal(0.02) # Assume 2% risk-free rate++ excess_return = expected_return - (risk_free_rate * time_period)+ sharpe = excess_return / (assumed_volatility * (time_period ** self.to_decimal(0.5)))++ return sharpe++ def _assess_carry_trade_risk(self, rate_differential: Decimal, leverage: Decimal) -> str:+ """Assess carry trade risk level"""+ risk_score = abs(rate_differential) * leverage++ if risk_score < self.to_decimal(0.02):+ return "Low"+ elif risk_score < self.to_decimal(0.05):+ return "Medium"+ else:+ return "High"++ def carry_trade_uip_violation(self, rate_differential: Decimal,+ actual_fx_change: Decimal,+ time_period: Decimal) -> Dict[str, Any]:+ """Analyze carry trade in context of UIP violation"""+ # Under UIP, exchange rate should change to offset interest differential+ uip_predicted_change = -rate_differential * time_period++ # Actual violation+ uip_violation = actual_fx_change - uip_predicted_change++ # Carry trade profit from UIP violation+ carry_profit = rate_differential * time_period + uip_violation++ return {+ 'rate_differential': rate_differential,+ 'uip_predicted_fx_change': uip_predicted_change,+ 'actual_fx_change': actual_fx_change,+ 'uip_violation': uip_violation,+ 'carry_trade_profit': carry_profit,+ 'uip_violation_percentage': (uip_violation / abs(uip_predicted_change)) * self.to_decimal(+ 100) if uip_predicted_change != 0 else self.to_decimal(0),+ 'profitable': carry_profit > self.to_decimal(0)+ }++ def calculate(self, calculation_type: str = 'return', **kwargs) -> Dict[str, Any]:+ """Main carry trade calculation"""+ if calculation_type == 'return':+ return self.calculate_carry_trade_return(+ self.to_decimal(kwargs['funding_rate']),+ self.to_decimal(kwargs['target_rate']),+ self.to_decimal(kwargs['fx_change']),+ self.to_decimal(kwargs['time_period']),+ self.to_decimal(kwargs.get('leverage', 1))+ )+ elif calculation_type == 'uip_violation':+ return self.carry_trade_uip_violation(+ self.to_decimal(kwargs['rate_differential']),+ self.to_decimal(kwargs['actual_fx_change']),+ self.to_decimal(kwargs['time_period'])+ )+ else:+ raise ValidationError(f"Unknown calculation type: {calculation_type}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/data_handler.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/data_handler.pynew file mode 100644index 000000000..bbe532fbe--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/data_handler.py@@ -0,0 +1,1333 @@+"""+Economic Data Management Module+==============================++Universal data adapter and provider interfaces for economic analysis. Handles data from multiple sources including external APIs and manual input, providing standardized formats and validation for all economic analysis modules with CFA Institute compliance.++===== DATA SOURCES REQUIRED =====+INPUT:+ - External API data sources (World Bank, IMF, central banks)+ - Manual data input and user-provided datasets+ - Real-time economic indicators and market data+ - Historical time series and macroeconomic data+ - Currency exchange rate feeds and financial market data+ - Trade statistics and balance of payments data+ - Custom data sources and proprietary datasets++OUTPUT:+ - Standardized data containers with validation metadata+ - Cleaned and processed economic data series+ - Data quality assessments and validation reports+ - Unified data formats for cross-module compatibility+ - Cached data for performance optimization+ - Error handling and missing data imputation++PARAMETERS:+ - data_source: Data source identifier or API endpoint+ - data_type: Economic data category (GDP, inflation, etc.)+ - frequency: Data frequency (daily, monthly, quarterly, annual)+ - start_date: Data collection start date+ - end_date: Data collection end date+ - countries: List of countries for data collection+ - indicators: Specific economic indicators to retrieve+ - api_key: Authentication key for external APIs+ - cache_duration: Data cache expiration time+"""++import json+import requests+import pandas as pd+import numpy as np+from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any, Union+from datetime import datetime, timedelta+from abc import ABC, abstractmethod+import logging+from .core import EconomicsBase, ValidationError, CalculationError, DataError, DataContainer++logger = logging.getLogger(__name__)+++class DataProvider(ABC):+ """Abstract base class for data providers"""++ def __init__(self, provider_name: str, api_key: Optional[str] = None):+ self.provider_name = provider_name+ self.api_key = api_key+ self.last_request_time = None+ self.rate_limit_delay = 1.0 # seconds between requests++ @abstractmethod+ def get_exchange_rates(self, base_currency: str, target_currencies: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get exchange rate data"""+ pass++ @abstractmethod+ def get_economic_indicators(self, country: str, indicators: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get economic indicator data"""+ pass++ @abstractmethod+ def get_interest_rates(self, country: str, rate_types: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get interest rate data"""+ pass++ def _rate_limit(self):+ """Implement rate limiting"""+ if self.last_request_time:+ time_since_last = datetime.now() - self.last_request_time+ if time_since_last.total_seconds() < self.rate_limit_delay:+ import time+ time.sleep(self.rate_limit_delay - time_since_last.total_seconds())+ self.last_request_time = datetime.now()++ def _handle_api_error(self, response: requests.Response, context: str = ""):+ """Handle API response errors"""+ if not response.ok:+ error_msg = f"{self.provider_name} API error ({response.status_code})"+ if context:+ error_msg += f" in {context}"+ error_msg += f": {response.text}"+ raise DataError(error_msg)+++class FREDConnector(DataProvider):+ """Federal Reserve Economic Data (FRED) API connector"""++ def __init__(self, api_key: str):+ super().__init__("FRED", api_key)+ self.base_url = "https://api.stlouisfed.org/fred"+ self.rate_limit_delay = 0.5 # FRED allows 120 requests per minute++ def get_exchange_rates(self, base_currency: str, target_currencies: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get exchange rates from FRED"""++ # FRED exchange rate series mapping+ fx_series_map = {+ 'USD': {+ 'EUR': 'DEXUSEU',+ 'GBP': 'DEXUSUK',+ 'JPY': 'DEXJPUS',+ 'CAD': 'DEXCAUS',+ 'CHF': 'DEXSZUS',+ 'AUD': 'DEXUSAL'+ }+ }++ if base_currency not in fx_series_map:+ raise DataError(f"Base currency {base_currency} not supported by FRED")++ fx_data = {}+ for target_currency in target_currencies:+ if target_currency not in fx_series_map[base_currency]:+ logger.warning(f"Exchange rate {base_currency}/{target_currency} not available from FRED")+ continue++ series_id = fx_series_map[base_currency][target_currency]+ data = self._get_fred_series(series_id, start_date, end_date)+ fx_data[f"{base_currency}/{target_currency}"] = data++ if not fx_data:+ raise DataError("No exchange rate data retrieved")++ return pd.DataFrame(fx_data)++ def get_economic_indicators(self, country: str, indicators: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get economic indicators from FRED"""++ # FRED economic indicator series mapping+ us_indicators_map = {+ 'gdp': 'GDP',+ 'gdp_growth': 'A191RL1Q225SBEA',+ 'inflation': 'CPIAUCSL',+ 'unemployment': 'UNRATE',+ 'interest_rate': 'FEDFUNDS',+ 'industrial_production': 'INDPRO',+ 'consumer_confidence': 'UMCSENT',+ 'trade_balance': 'BOPGSTB',+ 'government_debt': 'GFDEBTN'+ }++ if country.upper() != 'US':+ raise DataError(f"FRED primarily supports US data, country {country} not available")++ indicator_data = {}+ for indicator in indicators:+ if indicator.lower() not in us_indicators_map:+ logger.warning(f"Indicator {indicator} not available from FRED")+ continue++ series_id = us_indicators_map[indicator.lower()]+ data = self._get_fred_series(series_id, start_date, end_date)+ indicator_data[indicator] = data++ if not indicator_data:+ raise DataError("No economic indicator data retrieved")++ return pd.DataFrame(indicator_data)++ def get_interest_rates(self, country: str, rate_types: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get interest rates from FRED"""++ us_rates_map = {+ 'federal_funds': 'FEDFUNDS',+ '10_year_treasury': 'GS10',+ '2_year_treasury': 'GS2',+ '3_month_treasury': 'GS3M',+ 'prime_rate': 'PRIME',+ 'corporate_aaa': 'AAA',+ 'corporate_baa': 'BAA'+ }++ if country.upper() != 'US':+ raise DataError(f"FRED primarily supports US data, country {country} not available")++ rate_data = {}+ for rate_type in rate_types:+ if rate_type.lower() not in us_rates_map:+ logger.warning(f"Interest rate {rate_type} not available from FRED")+ continue++ series_id = us_rates_map[rate_type.lower()]+ data = self._get_fred_series(series_id, start_date, end_date)+ rate_data[rate_type] = data++ if not rate_data:+ raise DataError("No interest rate data retrieved")++ return pd.DataFrame(rate_data)++ def _get_fred_series(self, series_id: str, start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.Series:+ """Get individual FRED series data"""++ self._rate_limit()++ params = {+ 'series_id': series_id,+ 'api_key': self.api_key,+ 'file_type': 'json'+ }++ if start_date:+ params['observation_start'] = start_date.strftime('%Y-%m-%d')+ if end_date:+ params['observation_end'] = end_date.strftime('%Y-%m-%d')++ url = f"{self.base_url}/series/observations"++ try:+ response = requests.get(url, params=params)+ self._handle_api_error(response, f"series {series_id}")++ data = response.json()+ observations = data.get('observations', [])++ if not observations:+ raise DataError(f"No data returned for series {series_id}")++ # Convert to pandas Series+ dates = []+ values = []++ for obs in observations:+ if obs['value'] != '.': # FRED uses '.' for missing values+ try:+ dates.append(pd.to_datetime(obs['date']))+ values.append(float(obs['value']))+ except (ValueError, KeyError):+ continue++ if not dates:+ raise DataError(f"No valid data points for series {series_id}")++ return pd.Series(values, index=dates, name=series_id)++ except requests.exceptions.RequestException as e:+ raise DataError(f"Network error accessing FRED API: {e}")+ except json.JSONDecodeError as e:+ raise DataError(f"Invalid JSON response from FRED API: {e}")+++class AlphaVantageConnector(DataProvider):+ """Alpha Vantage API connector for FX and economic data"""++ def __init__(self, api_key: str):+ super().__init__("Alpha Vantage", api_key)+ self.base_url = "https://www.alphavantage.co/query"+ self.rate_limit_delay = 12.0 # Free tier: 5 requests per minute++ def get_exchange_rates(self, base_currency: str, target_currencies: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get exchange rates from Alpha Vantage"""++ fx_data = {}++ for target_currency in target_currencies:+ self._rate_limit()++ params = {+ 'function': 'FX_DAILY',+ 'from_symbol': base_currency,+ 'to_symbol': target_currency,+ 'apikey': self.api_key,+ 'outputsize': 'full'+ }++ try:+ response = requests.get(self.base_url, params=params)+ self._handle_api_error(response, f"FX data {base_currency}/{target_currency}")++ data = response.json()++ if 'Error Message' in data:+ logger.warning(+ f"Alpha Vantage error for {base_currency}/{target_currency}: {data['Error Message']}")+ continue++ if 'Note' in data:+ raise DataError(f"Alpha Vantage rate limit exceeded: {data['Note']}")++ time_series = data.get('Time Series FX (Daily)', {})++ if not time_series:+ logger.warning(f"No FX data returned for {base_currency}/{target_currency}")+ continue++ # Convert to pandas Series+ dates = []+ values = []++ for date_str, daily_data in time_series.items():+ date = pd.to_datetime(date_str)++ # Filter by date range if specified+ if start_date and date < start_date:+ continue+ if end_date and date > end_date:+ continue++ dates.append(date)+ values.append(float(daily_data['4. close']))++ if dates:+ fx_data[f"{base_currency}/{target_currency}"] = pd.Series(+ values, index=dates, name=f"{base_currency}/{target_currency}"+ ).sort_index()++ except requests.exceptions.RequestException as e:+ raise DataError(f"Network error accessing Alpha Vantage API: {e}")+ except json.JSONDecodeError as e:+ raise DataError(f"Invalid JSON response from Alpha Vantage API: {e}")++ if not fx_data:+ raise DataError("No exchange rate data retrieved from Alpha Vantage")++ return pd.DataFrame(fx_data)++ def get_economic_indicators(self, country: str, indicators: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get economic indicators from Alpha Vantage"""++ # Alpha Vantage economic indicators mapping+ indicators_map = {+ 'gdp': 'REAL_GDP',+ 'gdp_quarterly': 'REAL_GDP_PER_CAPITA',+ 'unemployment': 'UNEMPLOYMENT',+ 'inflation': 'INFLATION',+ 'interest_rate': 'FEDERAL_FUNDS_RATE',+ 'consumer_confidence': 'CONSUMER_SENTIMENT'+ }++ if country.upper() != 'US':+ raise DataError(f"Alpha Vantage economic indicators only available for US")++ indicator_data = {}++ for indicator in indicators:+ if indicator.lower() not in indicators_map:+ logger.warning(f"Indicator {indicator} not available from Alpha Vantage")+ continue++ self._rate_limit()++ params = {+ 'function': indicators_map[indicator.lower()],+ 'apikey': self.api_key+ }++ try:+ response = requests.get(self.base_url, params=params)+ self._handle_api_error(response, f"economic indicator {indicator}")++ data = response.json()++ if 'Error Message' in data:+ logger.warning(f"Alpha Vantage error for {indicator}: {data['Error Message']}")+ continue++ # Extract time series data (structure varies by indicator)+ time_series_key = None+ for key in data.keys():+ if 'data' in key.lower() or 'time series' in key.lower():+ time_series_key = key+ break++ if not time_series_key:+ logger.warning(f"No time series data found for {indicator}")+ continue++ time_series = data[time_series_key]++ dates = []+ values = []++ for item in time_series:+ date = pd.to_datetime(item['date'])++ # Filter by date range if specified+ if start_date and date < start_date:+ continue+ if end_date and date > end_date:+ continue++ dates.append(date)+ values.append(float(item['value']))++ if dates:+ indicator_data[indicator] = pd.Series(+ values, index=dates, name=indicator+ ).sort_index()++ except requests.exceptions.RequestException as e:+ raise DataError(f"Network error accessing Alpha Vantage API: {e}")+ except json.JSONDecodeError as e:+ raise DataError(f"Invalid JSON response from Alpha Vantage API: {e}")++ if not indicator_data:+ raise DataError("No economic indicator data retrieved from Alpha Vantage")++ return pd.DataFrame(indicator_data)++ def get_interest_rates(self, country: str, rate_types: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get interest rates from Alpha Vantage"""++ rate_functions = {+ 'federal_funds': 'FEDERAL_FUNDS_RATE',+ '10_year_treasury': 'TREASURY_YIELD',+ '3_month_treasury': 'TREASURY_YIELD'+ }++ if country.upper() != 'US':+ raise DataError(f"Alpha Vantage interest rates only available for US")++ rate_data = {}++ for rate_type in rate_types:+ if rate_type.lower() not in rate_functions:+ logger.warning(f"Interest rate {rate_type} not available from Alpha Vantage")+ continue++ self._rate_limit()++ params = {+ 'function': rate_functions[rate_type.lower()],+ 'apikey': self.api_key+ }++ # Add maturity parameter for treasury yields+ if 'treasury' in rate_type.lower():+ if '10_year' in rate_type.lower():+ params['maturity'] = '10year'+ elif '3_month' in rate_type.lower():+ params['maturity'] = '3month'++ try:+ response = requests.get(self.base_url, params=params)+ self._handle_api_error(response, f"interest rate {rate_type}")++ data = response.json()++ if 'Error Message' in data:+ logger.warning(f"Alpha Vantage error for {rate_type}: {data['Error Message']}")+ continue++ # Extract and process data similar to economic indicators+ time_series_key = None+ for key in data.keys():+ if 'data' in key.lower():+ time_series_key = key+ break++ if time_series_key:+ time_series = data[time_series_key]++ dates = []+ values = []++ for item in time_series:+ date = pd.to_datetime(item['date'])++ if start_date and date < start_date:+ continue+ if end_date and date > end_date:+ continue++ dates.append(date)+ values.append(float(item['value']))++ if dates:+ rate_data[rate_type] = pd.Series(+ values, index=dates, name=rate_type+ ).sort_index()++ except requests.exceptions.RequestException as e:+ raise DataError(f"Network error accessing Alpha Vantage API: {e}")+ except json.JSONDecodeError as e:+ raise DataError(f"Invalid JSON response from Alpha Vantage API: {e}")++ if not rate_data:+ raise DataError("No interest rate data retrieved from Alpha Vantage")++ return pd.DataFrame(rate_data)+++class ManualDataInput(DataProvider):+ """Manual data input interface for user-provided data"""++ def __init__(self):+ super().__init__("Manual Input")+ self.data_store = {}++ def add_exchange_rate_data(self, currency_pair: str, dates: List[datetime],+ rates: List[float]):+ """Add manual exchange rate data"""+ if len(dates) != len(rates):+ raise ValidationError("Dates and rates lists must have same length")++ df = pd.DataFrame({+ 'date': dates,+ 'rate': rates+ }).set_index('date')++ if 'exchange_rates' not in self.data_store:+ self.data_store['exchange_rates'] = {}++ self.data_store['exchange_rates'][currency_pair] = df['rate']++ def add_economic_indicator_data(self, country: str, indicator: str,+ dates: List[datetime], values: List[float]):+ """Add manual economic indicator data"""+ if len(dates) != len(values):+ raise ValidationError("Dates and values lists must have same length")++ df = pd.DataFrame({+ 'date': dates,+ 'value': values+ }).set_index('date')++ if 'economic_indicators' not in self.data_store:+ self.data_store['economic_indicators'] = {}+ if country not in self.data_store['economic_indicators']:+ self.data_store['economic_indicators'][country] = {}++ self.data_store['economic_indicators'][country][indicator] = df['value']++ def add_interest_rate_data(self, country: str, rate_type: str,+ dates: List[datetime], rates: List[float]):+ """Add manual interest rate data"""+ if len(dates) != len(rates):+ raise ValidationError("Dates and rates lists must have same length")++ df = pd.DataFrame({+ 'date': dates,+ 'rate': rates+ }).set_index('date')++ if 'interest_rates' not in self.data_store:+ self.data_store['interest_rates'] = {}+ if country not in self.data_store['interest_rates']:+ self.data_store['interest_rates'][country] = {}++ self.data_store['interest_rates'][country][rate_type] = df['rate']++ def load_from_csv(self, file_path: str, data_type: str, **kwargs):+ """Load data from CSV file"""+ try:+ df = pd.read_csv(file_path)++ if data_type == 'exchange_rates':+ self._load_fx_from_csv(df, **kwargs)+ elif data_type == 'economic_indicators':+ self._load_indicators_from_csv(df, **kwargs)+ elif data_type == 'interest_rates':+ self._load_rates_from_csv(df, **kwargs)+ else:+ raise ValidationError(f"Unknown data type: {data_type}")++ except Exception as e:+ raise DataError(f"Error loading CSV file {file_path}: {e}")++ def _load_fx_from_csv(self, df: pd.DataFrame, date_column: str = 'date', **kwargs):+ """Load FX data from CSV"""+ if date_column not in df.columns:+ raise ValidationError(f"Date column '{date_column}' not found in CSV")++ df[date_column] = pd.to_datetime(df[date_column])+ df.set_index(date_column, inplace=True)++ if 'exchange_rates' not in self.data_store:+ self.data_store['exchange_rates'] = {}++ for column in df.columns:+ if column != date_column:+ self.data_store['exchange_rates'][column] = df[column]++ def _load_indicators_from_csv(self, df: pd.DataFrame, country: str,+ date_column: str = 'date', **kwargs):+ """Load economic indicators from CSV"""+ if date_column not in df.columns:+ raise ValidationError(f"Date column '{date_column}' not found in CSV")++ df[date_column] = pd.to_datetime(df[date_column])+ df.set_index(date_column, inplace=True)++ if 'economic_indicators' not in self.data_store:+ self.data_store['economic_indicators'] = {}+ if country not in self.data_store['economic_indicators']:+ self.data_store['economic_indicators'][country] = {}++ for column in df.columns:+ if column != date_column:+ self.data_store['economic_indicators'][country][column] = df[column]++ def _load_rates_from_csv(self, df: pd.DataFrame, country: str,+ date_column: str = 'date', **kwargs):+ """Load interest rates from CSV"""+ if date_column not in df.columns:+ raise ValidationError(f"Date column '{date_column}' not found in CSV")++ df[date_column] = pd.to_datetime(df[date_column])+ df.set_index(date_column, inplace=True)++ if 'interest_rates' not in self.data_store:+ self.data_store['interest_rates'] = {}+ if country not in self.data_store['interest_rates']:+ self.data_store['interest_rates'][country] = {}++ for column in df.columns:+ if column != date_column:+ self.data_store['interest_rates'][country][column] = df[column]++ def get_exchange_rates(self, base_currency: str, target_currencies: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get exchange rates from manual data store"""++ if 'exchange_rates' not in self.data_store:+ raise DataError("No exchange rate data available")++ fx_data = {}++ for target_currency in target_currencies:+ pair = f"{base_currency}/{target_currency}"++ if pair in self.data_store['exchange_rates']:+ series = self.data_store['exchange_rates'][pair]++ # Filter by date range if specified+ if start_date or end_date:+ mask = pd.Series(True, index=series.index)+ if start_date:+ mask &= series.index >= start_date+ if end_date:+ mask &= series.index <= end_date+ series = series[mask]++ fx_data[pair] = series+ else:+ logger.warning(f"Exchange rate {pair} not found in manual data")++ if not fx_data:+ raise DataError("No matching exchange rate data found")++ return pd.DataFrame(fx_data)++ def get_economic_indicators(self, country: str, indicators: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get economic indicators from manual data store"""++ if 'economic_indicators' not in self.data_store:+ raise DataError("No economic indicator data available")++ if country not in self.data_store['economic_indicators']:+ raise DataError(f"No data available for country {country}")++ indicator_data = {}+ country_data = self.data_store['economic_indicators'][country]++ for indicator in indicators:+ if indicator in country_data:+ series = country_data[indicator]++ # Filter by date range if specified+ if start_date or end_date:+ mask = pd.Series(True, index=series.index)+ if start_date:+ mask &= series.index >= start_date+ if end_date:+ mask &= series.index <= end_date+ series = series[mask]++ indicator_data[indicator] = series+ else:+ logger.warning(f"Indicator {indicator} not found for {country}")++ if not indicator_data:+ raise DataError("No matching economic indicator data found")++ return pd.DataFrame(indicator_data)++ def get_interest_rates(self, country: str, rate_types: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> pd.DataFrame:+ """Get interest rates from manual data store"""++ if 'interest_rates' not in self.data_store:+ raise DataError("No interest rate data available")++ if country not in self.data_store['interest_rates']:+ raise DataError(f"No interest rate data available for country {country}")++ rate_data = {}+ country_data = self.data_store['interest_rates'][country]++ for rate_type in rate_types:+ if rate_type in country_data:+ series = country_data[rate_type]++ # Filter by date range if specified+ if start_date or end_date:+ mask = pd.Series(True, index=series.index)+ if start_date:+ mask &= series.index >= start_date+ if end_date:+ mask &= series.index <= end_date+ series = series[mask]++ rate_data[rate_type] = series+ else:+ logger.warning(f"Interest rate {rate_type} not found for {country}")++ if not rate_data:+ raise DataError("No matching interest rate data found")++ return pd.DataFrame(rate_data)+++class DataStandardizer(EconomicsBase):+ """Data standardization and normalization utilities"""++ def __init__(self, precision: int = 8):+ super().__init__(precision)++ def standardize_exchange_rates(self, fx_data: pd.DataFrame,+ target_frequency: str = 'D') -> pd.DataFrame:+ """Standardize exchange rate data format and frequency"""++ if fx_data.empty:+ raise ValidationError("Empty exchange rate data provided")++ # Ensure datetime index+ if not isinstance(fx_data.index, pd.DatetimeIndex):+ raise ValidationError("Exchange rate data must have datetime index")++ # Remove any non-numeric data+ fx_data = fx_data.select_dtypes(include=[np.number])++ # Resample to target frequency+ if target_frequency != 'D':+ fx_data = fx_data.resample(target_frequency).last()++ # Forward fill missing values (carry forward last observation)+ fx_data = fx_data.fillna(method='ffill')++ # Drop any remaining NaN values+ fx_data = fx_data.dropna()++ # Convert to high precision decimals+ for column in fx_data.columns:+ fx_data[column] = fx_data[column].apply(lambda x: self.to_decimal(x) if pd.notna(x) else None)++ return fx_data++ def standardize_economic_indicators(self, indicator_data: pd.DataFrame,+ target_frequency: str = 'M') -> pd.DataFrame:+ """Standardize economic indicator data format and frequency"""++ if indicator_data.empty:+ raise ValidationError("Empty economic indicator data provided")++ # Ensure datetime index+ if not isinstance(indicator_data.index, pd.DatetimeIndex):+ raise ValidationError("Economic indicator data must have datetime index")++ # Remove any non-numeric data+ indicator_data = indicator_data.select_dtypes(include=[np.number])++ # Resample to target frequency (typically monthly for economic data)+ if target_frequency != 'M':+ # Use appropriate aggregation method based on data type+ indicator_data = indicator_data.resample(target_frequency).mean()++ # Handle missing values more carefully for economic data+ indicator_data = indicator_data.fillna(method='ffill', limit=3) # Max 3 forward fills++ # Convert to high precision decimals+ for column in indicator_data.columns:+ indicator_data[column] = indicator_data[column].apply(+ lambda x: self.to_decimal(x) if pd.notna(x) else None+ )++ return indicator_data++ def calculate_returns(self, price_data: pd.DataFrame,+ return_type: str = 'simple') -> pd.DataFrame:+ """Calculate returns from price data"""++ if price_data.empty:+ raise ValidationError("Empty price data provided")++ returns_data = pd.DataFrame(index=price_data.index)++ for column in price_data.columns:+ if return_type.lower() == 'simple':+ # Simple returns: (P_t - P_t-1) / P_t-1+ returns_data[f"{column}_return"] = price_data[column].pct_change()+ elif return_type.lower() == 'log':+ # Log returns: ln(P_t / P_t-1)+ returns_data[f"{column}_return"] = np.log(price_data[column] / price_data[column].shift(1))+ else:+ raise ValidationError(f"Unknown return type: {return_type}")++ # Remove first row (NaN from pct_change)+ returns_data = returns_data.dropna()++ return returns_data++ def align_time_series(self, *dataframes: pd.DataFrame,+ join_method: str = 'inner') -> List[pd.DataFrame]:+ """Align multiple time series to common dates"""++ if not dataframes:+ raise ValidationError("No dataframes provided for alignment")++ # Find common date range+ if join_method == 'inner':+ # Use intersection of all date ranges+ common_dates = dataframes[0].index+ for df in dataframes[1:]:+ common_dates = common_dates.intersection(df.index)+ elif join_method == 'outer':+ # Use union of all date ranges+ common_dates = dataframes[0].index+ for df in dataframes[1:]:+ common_dates = common_dates.union(df.index)+ else:+ raise ValidationError(f"Unknown join method: {join_method}")++ if common_dates.empty:+ raise DataError("No common dates found across time series")++ # Reindex all dataframes to common dates+ aligned_dfs = []+ for df in dataframes:+ aligned_df = df.reindex(common_dates)+ if join_method == 'outer':+ # Forward fill missing values for outer join+ aligned_df = aligned_df.fillna(method='ffill')+ aligned_dfs.append(aligned_df)++ return aligned_dfs++ def detect_outliers(self, data: pd.Series, method: str = 'iqr',+ threshold: float = 1.5) -> pd.Series:+ """Detect outliers in time series data"""++ if data.empty:+ raise ValidationError("Empty data series provided")++ outliers = pd.Series(False, index=data.index)++ if method.lower() == 'iqr':+ # Interquartile range method+ Q1 = data.quantile(0.25)+ Q3 = data.quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - threshold * IQR+ upper_bound = Q3 + threshold * IQR+ outliers = (data < lower_bound) | (data > upper_bound)++ elif method.lower() == 'zscore':+ # Z-score method+ z_scores = np.abs((data - data.mean()) / data.std())+ outliers = z_scores > threshold++ elif method.lower() == 'modified_zscore':+ # Modified Z-score using median+ median = data.median()+ mad = np.median(np.abs(data - median))+ modified_z_scores = 0.6745 * (data - median) / mad+ outliers = np.abs(modified_z_scores) > threshold++ else:+ raise ValidationError(f"Unknown outlier detection method: {method}")++ return outliers++ def clean_data(self, data: pd.DataFrame,+ remove_outliers: bool = True,+ outlier_method: str = 'iqr',+ fill_missing: bool = True,+ fill_method: str = 'ffill') -> pd.DataFrame:+ """Comprehensive data cleaning"""++ cleaned_data = data.copy()++ # Remove outliers if requested+ if remove_outliers:+ for column in cleaned_data.select_dtypes(include=[np.number]).columns:+ outliers = self.detect_outliers(cleaned_data[column], method=outlier_method)+ cleaned_data.loc[outliers, column] = np.nan++ # Fill missing values if requested+ if fill_missing:+ if fill_method == 'ffill':+ cleaned_data = cleaned_data.fillna(method='ffill')+ elif fill_method == 'bfill':+ cleaned_data = cleaned_data.fillna(method='bfill')+ elif fill_method == 'interpolate':+ cleaned_data = cleaned_data.interpolate()+ elif fill_method == 'mean':+ cleaned_data = cleaned_data.fillna(cleaned_data.mean())+ else:+ raise ValidationError(f"Unknown fill method: {fill_method}")++ return cleaned_data+++class DataHandler(EconomicsBase):+ """Main data handler coordinating multiple data sources"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)+ self.providers = {}+ self.standardizer = DataStandardizer(precision)+ self.cache = {}+ self.cache_ttl = 3600 # 1 hour cache TTL++ def add_provider(self, provider_name: str, provider: DataProvider):+ """Add a data provider"""+ self.providers[provider_name] = provider+ logger.info(f"Added data provider: {provider_name}")++ def remove_provider(self, provider_name: str):+ """Remove a data provider"""+ if provider_name in self.providers:+ del self.providers[provider_name]+ logger.info(f"Removed data provider: {provider_name}")++ def list_providers(self) -> List[str]:+ """List available data providers"""+ return list(self.providers.keys())++ def get_exchange_rates(self, base_currency: str, target_currencies: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None,+ providers: Optional[List[str]] = None,+ standardize: bool = True) -> pd.DataFrame:+ """Get exchange rates from specified providers"""++ # Use all providers if none specified+ if providers is None:+ providers = list(self.providers.keys())++ # Check cache first+ cache_key = f"fx_{base_currency}_{'_'.join(target_currencies)}_{start_date}_{end_date}"+ if cache_key in self.cache:+ cache_entry = self.cache[cache_key]+ if datetime.now() - cache_entry['timestamp'] < timedelta(seconds=self.cache_ttl):+ logger.info(f"Returning cached exchange rate data")+ return cache_entry['data']++ all_data = []++ for provider_name in providers:+ if provider_name not in self.providers:+ logger.warning(f"Provider {provider_name} not available")+ continue++ try:+ provider = self.providers[provider_name]+ data = provider.get_exchange_rates(+ base_currency, target_currencies, start_date, end_date+ )++ if not data.empty:+ # Add provider suffix to column names+ data.columns = [f"{col}_{provider_name}" for col in data.columns]+ all_data.append(data)+ logger.info(f"Retrieved FX data from {provider_name}: {len(data)} rows")++ except Exception as e:+ logger.error(f"Error retrieving FX data from {provider_name}: {e}")+ continue++ if not all_data:+ raise DataError("No exchange rate data retrieved from any provider")++ # Combine data from all providers+ combined_data = pd.concat(all_data, axis=1, sort=True)++ # Standardize if requested+ if standardize:+ combined_data = self.standardizer.standardize_exchange_rates(combined_data)++ # Cache the result+ self.cache[cache_key] = {+ 'data': combined_data,+ 'timestamp': datetime.now()+ }++ return combined_data++ def get_economic_indicators(self, country: str, indicators: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None,+ providers: Optional[List[str]] = None,+ standardize: bool = True) -> pd.DataFrame:+ """Get economic indicators from specified providers"""++ # Use all providers if none specified+ if providers is None:+ providers = list(self.providers.keys())++ # Check cache first+ cache_key = f"indicators_{country}_{'_'.join(indicators)}_{start_date}_{end_date}"+ if cache_key in self.cache:+ cache_entry = self.cache[cache_key]+ if datetime.now() - cache_entry['timestamp'] < timedelta(seconds=self.cache_ttl):+ logger.info(f"Returning cached economic indicator data")+ return cache_entry['data']++ all_data = []++ for provider_name in providers:+ if provider_name not in self.providers:+ logger.warning(f"Provider {provider_name} not available")+ continue++ try:+ provider = self.providers[provider_name]+ data = provider.get_economic_indicators(+ country, indicators, start_date, end_date+ )++ if not data.empty:+ # Add provider suffix to column names+ data.columns = [f"{col}_{provider_name}" for col in data.columns]+ all_data.append(data)+ logger.info(f"Retrieved indicator data from {provider_name}: {len(data)} rows")++ except Exception as e:+ logger.error(f"Error retrieving indicator data from {provider_name}: {e}")+ continue++ if not all_data:+ raise DataError("No economic indicator data retrieved from any provider")++ # Combine data from all providers+ combined_data = pd.concat(all_data, axis=1, sort=True)++ # Standardize if requested+ if standardize:+ combined_data = self.standardizer.standardize_economic_indicators(combined_data)++ # Cache the result+ self.cache[cache_key] = {+ 'data': combined_data,+ 'timestamp': datetime.now()+ }++ return combined_data++ def get_interest_rates(self, country: str, rate_types: List[str],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None,+ providers: Optional[List[str]] = None,+ standardize: bool = True) -> pd.DataFrame:+ """Get interest rates from specified providers"""++ # Use all providers if none specified+ if providers is None:+ providers = list(self.providers.keys())++ # Check cache first+ cache_key = f"rates_{country}_{'_'.join(rate_types)}_{start_date}_{end_date}"+ if cache_key in self.cache:+ cache_entry = self.cache[cache_key]+ if datetime.now() - cache_entry['timestamp'] < timedelta(seconds=self.cache_ttl):+ logger.info(f"Returning cached interest rate data")+ return cache_entry['data']++ all_data = []++ for provider_name in providers:+ if provider_name not in self.providers:+ logger.warning(f"Provider {provider_name} not available")+ continue++ try:+ provider = self.providers[provider_name]+ data = provider.get_interest_rates(+ country, rate_types, start_date, end_date+ )++ if not data.empty:+ # Add provider suffix to column names+ data.columns = [f"{col}_{provider_name}" for col in data.columns]+ all_data.append(data)+ logger.info(f"Retrieved rate data from {provider_name}: {len(data)} rows")++ except Exception as e:+ logger.error(f"Error retrieving rate data from {provider_name}: {e}")+ continue++ if not all_data:+ raise DataError("No interest rate data retrieved from any provider")++ # Combine data from all providers+ combined_data = pd.concat(all_data, axis=1, sort=True)++ # Standardize if requested+ if standardize:+ combined_data = self.standardizer.standardize_economic_indicators(combined_data)++ # Cache the result+ self.cache[cache_key] = {+ 'data': combined_data,+ 'timestamp': datetime.now()+ }++ return combined_data++ def clear_cache(self):+ """Clear the data cache"""+ self.cache.clear()+ logger.info("Data cache cleared")++ def get_cache_stats(self) -> Dict[str, Any]:+ """Get cache statistics"""+ now = datetime.now()+ active_entries = 0+ expired_entries = 0++ for cache_entry in self.cache.values():+ if now - cache_entry['timestamp'] < timedelta(seconds=self.cache_ttl):+ active_entries += 1+ else:+ expired_entries += 1++ return {+ 'total_entries': len(self.cache),+ 'active_entries': active_entries,+ 'expired_entries': expired_entries,+ 'cache_ttl_seconds': self.cache_ttl+ }++ def validate_data_quality(self, data: pd.DataFrame,+ data_type: str = 'unknown') -> Dict[str, Any]:+ """Validate data quality and provide quality metrics"""++ if data.empty:+ return {+ 'quality_score': 0,+ 'issues': ['Empty dataset'],+ 'recommendations': ['Obtain data from reliable sources']+ }++ quality_metrics = {+ 'total_observations': len(data),+ 'total_variables': len(data.columns),+ 'missing_values': data.isnull().sum().sum(),+ 'missing_percentage': (data.isnull().sum().sum() / (len(data) * len(data.columns))) * 100,+ 'duplicate_rows': data.duplicated().sum(),+ 'date_range': f"{data.index.min()} to {data.index.max()}" if isinstance(data.index,+ pd.DatetimeIndex) else "Not time series"+ }++ # Detect outliers for numeric columns+ outlier_info = {}+ for column in data.select_dtypes(include=[np.number]).columns:+ outliers = self.standardizer.detect_outliers(data[column])+ outlier_info[column] = outliers.sum()++ quality_metrics['outliers_by_column'] = outlier_info+ quality_metrics['total_outliers'] = sum(outlier_info.values())++ # Calculate quality score (0-100)+ quality_score = 100++ # Deduct for missing values+ missing_penalty = min(quality_metrics['missing_percentage'] * 2, 50)+ quality_score -= missing_penalty++ # Deduct for outliers+ outlier_percentage = (quality_metrics['total_outliers'] / quality_metrics['total_observations']) * 100+ outlier_penalty = min(outlier_percentage * 1.5, 30)+ quality_score -= outlier_penalty++ # Deduct for duplicates+ duplicate_percentage = (quality_metrics['duplicate_rows'] / quality_metrics['total_observations']) * 100+ duplicate_penalty = min(duplicate_percentage * 3, 20)+ quality_score -= duplicate_penalty++ quality_score = max(0, quality_score) # Ensure non-negative++ # Generate issues and recommendations+ issues = []+ recommendations = []++ if quality_metrics['missing_percentage'] > 10:+ issues.append(f"High missing data rate: {quality_metrics['missing_percentage']:.1f}%")+ recommendations.append("Consider data imputation or alternative data sources")++ if outlier_percentage > 5:+ issues.append(f"High outlier rate: {outlier_percentage:.1f}%")+ recommendations.append("Review outliers for data errors or consider robust analysis methods")++ if quality_metrics['duplicate_rows'] > 0:+ issues.append(f"Found {quality_metrics['duplicate_rows']} duplicate rows")+ recommendations.append("Remove duplicate observations")++ if isinstance(data.index, pd.DatetimeIndex):+ # Check for gaps in time series+ expected_freq = pd.infer_freq(data.index)+ if expected_freq:+ expected_range = pd.date_range(start=data.index.min(),+ end=data.index.max(),+ freq=expected_freq)+ missing_dates = len(expected_range) - len(data.index)+ if missing_dates > 0:+ issues.append(f"Missing {missing_dates} time periods in series")+ recommendations.append("Fill missing time periods or adjust analysis for irregular data")++ return {+ 'quality_score': quality_score,+ 'quality_metrics': quality_metrics,+ 'issues': issues,+ 'recommendations': recommendations,+ 'data_type': data_type+ }++ def generate_data_summary(self, data: pd.DataFrame) -> Dict[str, Any]:+ """Generate comprehensive data summary"""++ summary = {+ 'basic_info': {+ 'shape': data.shape,+ 'data_types': data.dtypes.to_dict(),+ 'memory_usage': data.memory_usage(deep=True).sum(),+ 'index_type': type(data.index).__name__+ },+ 'statistical_summary': {},+ 'missing_data': {+ 'total_missing': data.isnull().sum().sum(),+ 'missing_by_column': data.isnull().sum().to_dict(),+ 'missing_percentage_by_column': (data.isnull().sum() / len(data) * 100).to_dict()+ }+ }++ # Statistical summary for numeric columns+ numeric_data = data.select_dtypes(include=[np.number])+ if not numeric_data.empty:+ summary['statistical_summary'] = {+ 'count': numeric_data.count().to_dict(),+ 'mean': numeric_data.mean().to_dict(),+ 'std': numeric_data.std().to_dict(),+ 'min': numeric_data.min().to_dict(),+ 'max': numeric_data.max().to_dict(),+ 'median': numeric_data.median().to_dict(),+ 'skewness': numeric_data.skew().to_dict(),+ 'kurtosis': numeric_data.kurtosis().to_dict()+ }++ # Time series specific information+ if isinstance(data.index, pd.DatetimeIndex):+ summary['time_series_info'] = {+ 'start_date': data.index.min(),+ 'end_date': data.index.max(),+ 'frequency': pd.infer_freq(data.index),+ 'total_periods': len(data.index),+ 'business_days_only': data.index.freq == 'B' if hasattr(data.index, 'freq') else False+ }++ return summary++ def calculate(self, operation: str, **kwargs) -> Any:+ """Main data handler operation dispatcher"""++ operations = {+ 'validate_quality': lambda: self.validate_data_quality(+ kwargs['data'], kwargs.get('data_type', 'unknown')+ ),+ 'generate_summary': lambda: self.generate_data_summary(kwargs['data']),+ 'standardize_fx': lambda: self.standardizer.standardize_exchange_rates(kwargs['data']),+ 'standardize_indicators': lambda: self.standardizer.standardize_economic_indicators(kwargs['data']),+ 'calculate_returns': lambda: self.standardizer.calculate_returns(+ kwargs['data'], kwargs.get('return_type', 'simple')+ ),+ 'align_series': lambda: self.standardizer.align_time_series(+ *kwargs['dataframes'], join_method=kwargs.get('join_method', 'inner')+ ),+ 'detect_outliers': lambda: self.standardizer.detect_outliers(+ kwargs['data'], kwargs.get('method', 'iqr'), kwargs.get('threshold', 1.5)+ ),+ 'clean_data': lambda: self.standardizer.clean_data(+ kwargs['data'],+ kwargs.get('remove_outliers', True),+ kwargs.get('outlier_method', 'iqr'),+ kwargs.get('fill_missing', True),+ kwargs.get('fill_method', 'ffill')+ )+ }++ if operation not in operations:+ raise ValidationError(f"Unknown data operation: {operation}")++ result = operations[operation]()++ # Add metadata for certain operations+ if operation in ['validate_quality', 'generate_summary']:+ if isinstance(result, dict):+ result['metadata'] = self.get_metadata()+ result['operation'] = operation++ return result\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/exchange_calculations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/exchange_calculations.pynew file mode 100644index 000000000..1dd2eeba9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/exchange_calculations.py@@ -0,0 +1,487 @@+"""+Exchange Rate Mathematical Calculations Module+=============================================++Professional exchange rate calculations implementing CFA Institute Level I curriculum. Provides mathematical operations for cross-rates, arbitrage relationships, forward calculations, and currency percentage changes with precision decimal arithmetic.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Spot exchange rates for major currency pairs+ - Forward exchange rates and forward points+ - Interest rate data for arbitrage calculations+ - Cross-currency exchange rate matrices+ - Historical exchange rate data for trend analysis+ - Market conventions and quote specifications+ - Currency quote base and terms specifications++OUTPUT:+ - Cross-rate calculations and implied exchange rates+ - Forward rate calculations from spot rates and interest differentials+ - Arbitrage opportunity identification and profit calculations+ - Forward premium/discount percentages and interpretations+ - Currency percentage change calculations and trend analysis+ - Bid-ask spread calculations and impact assessments+ - Professional exchange rate mathematical operations++PARAMETERS:+ - rate_a: Exchange rate for currency pair A+ - rate_b: Exchange rate for currency pair B+ - base_currency: Base currency for calculations+ - terms_currency: Terms currency for calculations+ - spot_rate: Current spot exchange rate+ - forward_points: Forward points for premium/discount+ - interest_rate_a: Interest rate for currency A+ - interest_rate_b: Interest rate for currency B+ - time_period: Time period for forward calculations+ - initial_rate: Starting exchange rate+ - final_rate: Ending exchange rate+ - bid_rate: Bid price for currency pair+ - ask_rate: Ask price for currency pair+"""++from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any+from datetime import datetime, timedelta+import pandas as pd+from .core import EconomicsBase, ValidationError, CalculationError, DataError+++class ExchangeCalculator(EconomicsBase):+ """Main exchange rate calculations coordinator"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)+ self.cross_rate = CrossRateCalculator(precision, base_currency)+ self.forward_calc = ForwardCalculator(precision, base_currency)++ def calculate(self, calculation_type: str, **kwargs) -> Dict[str, Any]:+ """Route calculation to appropriate calculator"""+ calculators = {+ 'cross_rate': self.cross_rate.calculate,+ 'forward_rate': self.forward_calc.calculate,+ 'percentage_change': self.calculate_percentage_change,+ 'arbitrage_check': self.check_arbitrage_relationship+ }++ if calculation_type not in calculators:+ raise ValidationError(f"Unknown calculation type: {calculation_type}")++ return calculators[calculation_type](**kwargs)++ def calculate_percentage_change(self, initial_rate: Decimal, final_rate: Decimal,+ quote_convention: str = 'direct') -> Dict[str, Any]:+ """Calculate percentage change in currency relative to another"""+ initial = self.to_decimal(initial_rate)+ final = self.to_decimal(final_rate)++ self.validator.validate_exchange_rate(initial)+ self.validator.validate_exchange_rate(final)++ if quote_convention == 'direct':+ # Direct quote: domestic currency per unit of foreign currency+ # Increase means domestic currency weakening+ percentage_change = ((final - initial) / initial) * self.to_decimal(100)+ currency_movement = 'weakened' if percentage_change > 0 else 'strengthened'+ else:+ # Indirect quote: foreign currency per unit of domestic currency+ # Increase means domestic currency strengthening+ percentage_change = ((final - initial) / initial) * self.to_decimal(100)+ currency_movement = 'strengthened' if percentage_change > 0 else 'weakened'++ return {+ 'initial_rate': initial,+ 'final_rate': final,+ 'percentage_change': percentage_change,+ 'absolute_change': final - initial,+ 'quote_convention': quote_convention,+ 'currency_movement': currency_movement,+ 'interpretation': self._interpret_currency_change(percentage_change, quote_convention)+ }++ def _interpret_currency_change(self, change: Decimal, convention: str) -> str:+ """Provide interpretation of currency movement"""+ abs_change = abs(change)++ if abs_change < self.to_decimal(0.5):+ magnitude = "minimal"+ elif abs_change < self.to_decimal(2):+ magnitude = "moderate"+ elif abs_change < self.to_decimal(5):+ magnitude = "significant"+ else:+ magnitude = "substantial"++ direction = "appreciation" if change > 0 else "depreciation"+ if convention == 'indirect':+ direction = "depreciation" if change > 0 else "appreciation"++ return f"{magnitude} {direction} ({abs_change:.2f}%)"++ def check_arbitrage_relationship(self, spot_rate: Decimal, forward_rate: Decimal,+ domestic_rate: Decimal, foreign_rate: Decimal,+ time_period: Decimal) -> Dict[str, Any]:+ """Check arbitrage relationship between spot/forward rates and interest rates"""+ spot = self.to_decimal(spot_rate)+ forward = self.to_decimal(forward_rate)+ r_domestic = self.to_decimal(domestic_rate)+ r_foreign = self.to_decimal(foreign_rate)+ t = self.to_decimal(time_period)++ # Theoretical forward rate based on interest rate parity+ theoretical_forward = spot * (+ (self.to_decimal(1) + r_domestic * t) /+ (self.to_decimal(1) + r_foreign * t)+ )++ deviation = forward - theoretical_forward+ deviation_percentage = (deviation / theoretical_forward) * self.to_decimal(100)++ # Arbitrage opportunity threshold (typical transaction costs)+ arbitrage_threshold = self.to_decimal(0.1) # 0.1%+ arbitrage_exists = abs(deviation_percentage) > arbitrage_threshold++ arbitrage_strategy = self._determine_arbitrage_strategy(+ deviation, spot, forward, r_domestic, r_foreign, t+ ) if arbitrage_exists else None++ return {+ 'spot_rate': spot,+ 'forward_rate': forward,+ 'theoretical_forward': theoretical_forward,+ 'deviation': deviation,+ 'deviation_percentage': deviation_percentage,+ 'arbitrage_exists': arbitrage_exists,+ 'arbitrage_strategy': arbitrage_strategy,+ 'domestic_rate': r_domestic,+ 'foreign_rate': r_foreign,+ 'time_period': t,+ 'relationship_holds': not arbitrage_exists+ }++ def _determine_arbitrage_strategy(self, deviation: Decimal, spot: Decimal,+ forward: Decimal, r_dom: Decimal, r_for: Decimal,+ t: Decimal) -> Dict[str, str]:+ """Determine arbitrage strategy when opportunity exists"""+ if deviation > 0: # Forward overpriced+ return {+ 'action': 'Sell forward, buy spot',+ 'step1': 'Borrow domestic currency',+ 'step2': 'Convert to foreign currency at spot rate',+ 'step3': 'Invest foreign currency at foreign rate',+ 'step4': 'Sell foreign currency forward',+ 'step5': 'At maturity: collect foreign investment, deliver to forward contract',+ 'profit_source': 'Forward rate higher than theoretical rate'+ }+ else: # Forward underpriced+ return {+ 'action': 'Buy forward, sell spot',+ 'step1': 'Borrow foreign currency',+ 'step2': 'Convert to domestic currency at spot rate',+ 'step3': 'Invest domestic currency at domestic rate',+ 'step4': 'Buy foreign currency forward',+ 'step5': 'At maturity: collect domestic investment, buy foreign currency via forward',+ 'profit_source': 'Forward rate lower than theoretical rate'+ }+++class CrossRateCalculator(EconomicsBase):+ """Currency cross-rate calculations and interpretations"""++ def calculate_cross_rate(self, base_quote_rates: Dict[str, Decimal],+ currency_pair: str) -> Dict[str, Any]:+ """Calculate cross-rate between two currencies using base currency"""+ pair_parts = currency_pair.split('/')+ if len(pair_parts) != 2:+ raise ValidationError("Currency pair must be in format 'CUR1/CUR2'")++ base_currency, quote_currency = pair_parts+ base_currency = base_currency.upper()+ quote_currency = quote_currency.upper()++ # Get rates vs base currency (typically USD)+ base_vs_reference = base_quote_rates.get(base_currency)+ quote_vs_reference = base_quote_rates.get(quote_currency)++ if base_vs_reference is None:+ raise DataError(f"Missing rate for {base_currency}")+ if quote_vs_reference is None:+ raise DataError(f"Missing rate for {quote_currency}")++ # Calculate cross rate+ cross_rate = quote_vs_reference / base_vs_reference++ # Calculate inverse rate+ inverse_rate = base_vs_reference / quote_vs_reference+ inverse_pair = f"{quote_currency}/{base_currency}"++ return {+ 'currency_pair': currency_pair,+ 'cross_rate': cross_rate,+ 'inverse_pair': inverse_pair,+ 'inverse_rate': inverse_rate,+ 'base_currency_rate': base_vs_reference,+ 'quote_currency_rate': quote_vs_reference,+ 'reference_currency': self.base_currency,+ 'calculation_method': f"{quote_currency}/{self.base_currency} ÷ {base_currency}/{self.base_currency}",+ 'interpretation': f"1 {base_currency} = {cross_rate:.6f} {quote_currency}"+ }++ def calculate_triangular_cross_rates(self, currency_rates: Dict[str, Decimal]) -> Dict[str, Any]:+ """Calculate all possible cross-rates from given currency rates"""+ currencies = list(currency_rates.keys())+ cross_rates = {}++ for i, base_curr in enumerate(currencies):+ for j, quote_curr in enumerate(currencies):+ if i != j:+ pair = f"{base_curr}/{quote_curr}"+ try:+ result = self.calculate_cross_rate(currency_rates, pair)+ cross_rates[pair] = {+ 'rate': result['cross_rate'],+ 'calculation': result['calculation_method']+ }+ except Exception as e:+ cross_rates[pair] = {'error': str(e)}++ return {+ 'cross_rates': cross_rates,+ 'total_pairs': len(cross_rates),+ 'input_currencies': currencies,+ 'reference_currency': self.base_currency,+ 'timestamp': datetime.now().isoformat()+ }++ def verify_cross_rate_consistency(self, rates: Dict[str, Decimal]) -> Dict[str, Any]:+ """Verify cross-rate consistency (no arbitrage condition)"""+ currencies = list(rates.keys())+ inconsistencies = []++ # Check triangular consistency for all combinations+ for i in range(len(currencies)):+ for j in range(i + 1, len(currencies)):+ for k in range(j + 1, len(currencies)):+ curr1, curr2, curr3 = currencies[i], currencies[j], currencies[k]++ # Calculate cross rates+ rate_12 = rates[curr2] / rates[curr1] # curr1/curr2+ rate_23 = rates[curr3] / rates[curr2] # curr2/curr3+ rate_31 = rates[curr1] / rates[curr3] # curr3/curr1++ # Check if rate_12 * rate_23 * rate_31 = 1+ product = rate_12 * rate_23 * rate_31+ deviation = abs(product - self.to_decimal(1))++ if deviation > self.to_decimal(0.0001): # 0.01% tolerance+ inconsistencies.append({+ 'currencies': [curr1, curr2, curr3],+ 'rates': [rate_12, rate_23, rate_31],+ 'product': product,+ 'deviation': deviation,+ 'deviation_percentage': deviation * self.to_decimal(100)+ })++ return {+ 'consistent': len(inconsistencies) == 0,+ 'inconsistencies': inconsistencies,+ 'total_combinations_checked': len(currencies) * (len(currencies) - 1) * (len(currencies) - 2) // 6,+ 'currencies_analyzed': currencies+ }++ def calculate(self, calculation_type: str = 'single', **kwargs) -> Dict[str, Any]:+ """Main cross-rate calculation dispatcher"""+ if calculation_type == 'single':+ return self.calculate_cross_rate(+ kwargs['base_quote_rates'],+ kwargs['currency_pair']+ )+ elif calculation_type == 'all_pairs':+ return self.calculate_triangular_cross_rates(kwargs['currency_rates'])+ elif calculation_type == 'consistency_check':+ return self.verify_cross_rate_consistency(kwargs['rates'])+ else:+ raise ValidationError(f"Unknown calculation type: {calculation_type}")+++class ForwardCalculator(EconomicsBase):+ """Forward rate calculations using points and percentage terms"""++ def calculate_forward_rate_from_points(self, spot_rate: Decimal, forward_points: Decimal,+ point_convention: str = 'standard') -> Dict[str, Any]:+ """Calculate forward rate from forward points"""+ spot = self.to_decimal(spot_rate)+ points = self.to_decimal(forward_points)++ self.validator.validate_exchange_rate(spot)++ if point_convention == 'standard':+ # Standard: points are in the last decimal place (typically 4th for major pairs)+ divisor = self.to_decimal(10000) # Standard 4 decimal places+ elif point_convention == 'big_figure':+ # Big figure: points are in pips (5th decimal place)+ divisor = self.to_decimal(100000)+ else:+ raise ValidationError(f"Unknown point convention: {point_convention}")++ # Calculate forward rate+ forward_rate = spot + (points / divisor)++ # Determine if premium or discount+ is_premium = forward_rate > spot+ premium_discount = forward_rate - spot+ premium_discount_percentage = (premium_discount / spot) * self.to_decimal(100)++ return {+ 'spot_rate': spot,+ 'forward_points': points,+ 'forward_rate': forward_rate,+ 'point_convention': point_convention,+ 'divisor': divisor,+ 'premium_discount': premium_discount,+ 'premium_discount_percentage': premium_discount_percentage,+ 'is_premium': is_premium,+ 'calculation': f"{spot} + ({points}/{divisor}) = {forward_rate}"+ }++ def calculate_forward_points_from_rate(self, spot_rate: Decimal, forward_rate: Decimal,+ point_convention: str = 'standard') -> Dict[str, Any]:+ """Calculate forward points from spot and forward rates"""+ spot = self.to_decimal(spot_rate)+ forward = self.to_decimal(forward_rate)++ self.validator.validate_exchange_rate(spot)+ self.validator.validate_exchange_rate(forward)++ if point_convention == 'standard':+ multiplier = self.to_decimal(10000)+ elif point_convention == 'big_figure':+ multiplier = self.to_decimal(100000)+ else:+ raise ValidationError(f"Unknown point convention: {point_convention}")++ # Calculate forward points+ forward_points = (forward - spot) * multiplier++ return {+ 'spot_rate': spot,+ 'forward_rate': forward,+ 'forward_points': forward_points,+ 'point_convention': point_convention,+ 'multiplier': multiplier,+ 'is_premium': forward > spot,+ 'calculation': f"({forward} - {spot}) × {multiplier} = {forward_points} points"+ }++ def calculate_forward_rate_percentage(self, spot_rate: Decimal, premium_discount_percent: Decimal,+ time_to_maturity: Decimal,+ annualized: bool = True) -> Dict[str, Any]:+ """Calculate forward rate from percentage premium/discount"""+ spot = self.to_decimal(spot_rate)+ premium_percent = self.to_decimal(premium_discount_percent)+ time_period = self.to_decimal(time_to_maturity)++ self.validator.validate_exchange_rate(spot)+ self.validator.validate_time_period(time_period)++ if annualized:+ # Convert annualized rate to period rate+ period_premium = premium_percent * time_period+ else:+ # Already a period rate+ period_premium = premium_percent++ # Calculate forward rate+ forward_rate = spot * (self.to_decimal(1) + period_premium / self.to_decimal(100))++ # Calculate equivalent annualized rate if input was period rate+ if not annualized:+ annualized_premium = period_premium / time_period+ else:+ annualized_premium = premium_percent++ return {+ 'spot_rate': spot,+ 'forward_rate': forward_rate,+ 'premium_discount_percent': premium_percent,+ 'time_to_maturity': time_period,+ 'period_premium': period_premium,+ 'annualized_premium': annualized_premium,+ 'is_annualized_input': annualized,+ 'is_premium': premium_percent > 0,+ 'calculation': f"{spot} × (1 + {period_premium}%) = {forward_rate}"+ }++ def interpret_forward_discount_premium(self, spot_rate: Decimal, forward_rate: Decimal,+ time_to_maturity: Decimal) -> Dict[str, Any]:+ """Interpret forward discount or premium"""+ spot = self.to_decimal(spot_rate)+ forward = self.to_decimal(forward_rate)+ time_period = self.to_decimal(time_to_maturity)++ # Calculate premium/discount+ absolute_difference = forward - spot+ percentage_difference = (absolute_difference / spot) * self.to_decimal(100)+ annualized_percentage = percentage_difference / time_period++ # Interpretation+ if forward > spot:+ interpretation = f"Forward premium of {percentage_difference:.4f}% ({annualized_percentage:.4f}% annualized)"+ market_expectation = "Base currency expected to weaken"+ interest_rate_implication = "Base currency likely has lower interest rates"+ elif forward < spot:+ interpretation = f"Forward discount of {abs(percentage_difference):.4f}% ({abs(annualized_percentage):.4f}% annualized)"+ market_expectation = "Base currency expected to strengthen"+ interest_rate_implication = "Base currency likely has higher interest rates"+ else:+ interpretation = "Forward rate equals spot rate (no premium or discount)"+ market_expectation = "No expected currency movement"+ interest_rate_implication = "Interest rates likely equal between currencies"++ return {+ 'spot_rate': spot,+ 'forward_rate': forward,+ 'absolute_difference': absolute_difference,+ 'percentage_difference': percentage_difference,+ 'annualized_percentage': annualized_percentage,+ 'time_to_maturity': time_period,+ 'interpretation': interpretation,+ 'market_expectation': market_expectation,+ 'interest_rate_implication': interest_rate_implication,+ 'is_premium': forward > spot,+ 'is_discount': forward < spot+ }++ def calculate(self, calculation_type: str, **kwargs) -> Dict[str, Any]:+ """Main forward calculation dispatcher"""+ calculations = {+ 'from_points': lambda: self.calculate_forward_rate_from_points(+ self.to_decimal(kwargs['spot_rate']),+ self.to_decimal(kwargs['forward_points']),+ kwargs.get('point_convention', 'standard')+ ),+ 'to_points': lambda: self.calculate_forward_points_from_rate(+ self.to_decimal(kwargs['spot_rate']),+ self.to_decimal(kwargs['forward_rate']),+ kwargs.get('point_convention', 'standard')+ ),+ 'from_percentage': lambda: self.calculate_forward_rate_percentage(+ self.to_decimal(kwargs['spot_rate']),+ self.to_decimal(kwargs['premium_discount_percent']),+ self.to_decimal(kwargs['time_to_maturity']),+ kwargs.get('annualized', True)+ ),+ 'interpret_premium_discount': lambda: self.interpret_forward_discount_premium(+ self.to_decimal(kwargs['spot_rate']),+ self.to_decimal(kwargs['forward_rate']),+ self.to_decimal(kwargs['time_to_maturity'])+ )+ }++ if calculation_type not in calculations:+ raise ValidationError(f"Unknown calculation type: {calculation_type}")++ result = calculations[calculation_type]()+ result['metadata'] = self.get_metadata()+ result['calculation_type'] = calculation_type++ return result\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/growth_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/growth_analysis.pynew file mode 100644index 000000000..457956bfe--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/growth_analysis.py@@ -0,0 +1,1022 @@++Economic Growth Analysis Module+=============================++Economic growth analysis and forecasting++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any, Union+from datetime import datetime, timedelta+import pandas as pd+import numpy as np+from .core import EconomicsBase, ValidationError, CalculationError, DataError, CalculationUtils+++class GrowthAnalyzer(EconomicsBase):+ """Main economic growth analysis coordinator"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)+ self.productivity = ProductivityAnalyzer(precision, base_currency)+ self.convergence = ConvergenceAnalyzer(precision, base_currency)+ self.demographic = DemographicAnalyzer(precision, base_currency)++ def compare_growth_factors(self, country_type: str, economic_data: Dict[str, Any]) -> Dict[str, Any]:+ """Compare factors favoring and limiting growth in developed vs developing economies"""++ if country_type.lower() not in ['developed', 'developing']:+ raise ValidationError("Country type must be 'developed' or 'developing'")++ if country_type.lower() == 'developed':+ return self._analyze_developed_economy_factors(economic_data)+ else:+ return self._analyze_developing_economy_factors(economic_data)++ def _analyze_developed_economy_factors(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze growth factors for developed economies"""++ # Extract key metrics+ gdp_per_capita = self.to_decimal(data.get('gdp_per_capita', 0))+ rd_spending = self.to_decimal(data.get('rd_spending_percent_gdp', 0))+ education_index = self.to_decimal(data.get('education_index', 0))+ infrastructure_quality = self.to_decimal(data.get('infrastructure_quality', 0))+ population_growth = self.to_decimal(data.get('population_growth_rate', 0))+ aging_ratio = self.to_decimal(data.get('old_age_dependency_ratio', 0))++ favoring_factors = {+ 'technological_innovation': {+ 'score': rd_spending * self.to_decimal(10), # R&D as % of GDP scaled+ 'description': 'High R&D spending drives innovation-led growth',+ 'weight': self.to_decimal(0.25)+ },+ 'human_capital': {+ 'score': education_index * self.to_decimal(100),+ 'description': 'Skilled workforce enables productivity gains',+ 'weight': self.to_decimal(0.20)+ },+ 'institutional_quality': {+ 'score': infrastructure_quality,+ 'description': 'Strong institutions support efficient markets',+ 'weight': self.to_decimal(0.20)+ },+ 'capital_deepening': {+ 'score': self.to_decimal(85), # Typically high in developed economies+ 'description': 'Existing capital stock supports productivity',+ 'weight': self.to_decimal(0.15)+ }+ }++ limiting_factors = {+ 'demographic_constraints': {+ 'score': aging_ratio,+ 'description': 'Aging population reduces labor force growth',+ 'weight': self.to_decimal(0.30)+ },+ 'diminishing_returns': {+ 'score': gdp_per_capita / self.to_decimal(1000), # Higher GDP per capita = more diminishing returns+ 'description': 'High income levels face diminishing marginal returns',+ 'weight': self.to_decimal(0.25)+ },+ 'low_population_growth': {+ 'score': max(self.to_decimal(0), self.to_decimal(2) - population_growth) * self.to_decimal(50),+ 'description': 'Low population growth limits labor force expansion',+ 'weight': self.to_decimal(0.20)+ },+ 'mature_economy_constraints': {+ 'score': self.to_decimal(70), # Fixed score for developed economies+ 'description': 'Limited catch-up growth opportunities',+ 'weight': self.to_decimal(0.25)+ }+ }++ # Calculate composite scores+ favoring_score = sum(factor['score'] * factor['weight'] for factor in favoring_factors.values())+ limiting_score = sum(factor['score'] * factor['weight'] for factor in limiting_factors.values())++ return {+ 'country_type': 'developed',+ 'favoring_factors': favoring_factors,+ 'limiting_factors': limiting_factors,+ 'composite_favoring_score': favoring_score,+ 'composite_limiting_score': limiting_score,+ 'net_growth_potential': favoring_score - limiting_score,+ 'primary_growth_drivers': ['technological_innovation', 'human_capital'],+ 'main_constraints': ['demographic_constraints', 'diminishing_returns']+ }++ def _analyze_developing_economy_factors(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze growth factors for developing economies"""++ # Extract key metrics+ gdp_per_capita = self.to_decimal(data.get('gdp_per_capita', 0))+ savings_rate = self.to_decimal(data.get('savings_rate', 0))+ fdi_inflows = self.to_decimal(data.get('fdi_percent_gdp', 0))+ population_growth = self.to_decimal(data.get('population_growth_rate', 0))+ institutional_quality = self.to_decimal(data.get('institutional_quality_index', 0))+ education_enrollment = self.to_decimal(data.get('secondary_education_enrollment', 0))++ favoring_factors = {+ 'catch_up_potential': {+ 'score': max(self.to_decimal(0), self.to_decimal(50) - gdp_per_capita / self.to_decimal(1000)),+ 'description': 'Low income levels allow rapid catch-up growth',+ 'weight': self.to_decimal(0.25)+ },+ 'demographic_dividend': {+ 'score': min(population_growth * self.to_decimal(25), self.to_decimal(100)),+ 'description': 'Young population provides growing workforce',+ 'weight': self.to_decimal(0.20)+ },+ 'capital_accumulation': {+ 'score': savings_rate * self.to_decimal(2),+ 'description': 'High savings enable capital investment',+ 'weight': self.to_decimal(0.20)+ },+ 'technology_transfer': {+ 'score': fdi_inflows * self.to_decimal(10),+ 'description': 'FDI brings advanced technology and knowledge',+ 'weight': self.to_decimal(0.15)+ },+ 'education_expansion': {+ 'score': education_enrollment,+ 'description': 'Growing human capital base',+ 'weight': self.to_decimal(0.20)+ }+ }++ limiting_factors = {+ 'institutional_weaknesses': {+ 'score': self.to_decimal(100) - institutional_quality,+ 'description': 'Weak institutions hinder efficient resource allocation',+ 'weight': self.to_decimal(0.30)+ },+ 'infrastructure_gaps': {+ 'score': self.to_decimal(80), # Typically high in developing countries+ 'description': 'Inadequate infrastructure limits productivity',+ 'weight': self.to_decimal(0.25)+ },+ 'human_capital_deficits': {+ 'score': self.to_decimal(100) - education_enrollment,+ 'description': 'Limited education reduces productivity potential',+ 'weight': self.to_decimal(0.20)+ },+ 'external_dependence': {+ 'score': self.to_decimal(60), # Moderate score for most developing economies+ 'description': 'Dependence on external financing and technology',+ 'weight': self.to_decimal(0.25)+ }+ }++ # Calculate composite scores+ favoring_score = sum(factor['score'] * factor['weight'] for factor in favoring_factors.values())+ limiting_score = sum(factor['score'] * factor['weight'] for factor in limiting_factors.values())++ return {+ 'country_type': 'developing',+ 'favoring_factors': favoring_factors,+ 'limiting_factors': limiting_factors,+ 'composite_favoring_score': favoring_score,+ 'composite_limiting_score': limiting_score,+ 'net_growth_potential': favoring_score - limiting_score,+ 'primary_growth_drivers': ['catch_up_potential', 'demographic_dividend'],+ 'main_constraints': ['institutional_weaknesses', 'infrastructure_gaps']+ }++ def analyze_stock_market_growth_relationship(self, market_data: Dict[str, Any],+ economic_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze relationship between stock market appreciation and sustainable growth rate"""++ # Market data+ stock_returns = [self.to_decimal(r) for r in market_data.get('annual_returns', [])]+ dividend_yield = self.to_decimal(market_data.get('dividend_yield', 0))+ pe_ratio = self.to_decimal(market_data.get('pe_ratio', 0))++ # Economic data+ gdp_growth = self.to_decimal(economic_data.get('gdp_growth_rate', 0))+ productivity_growth = self.to_decimal(economic_data.get('productivity_growth', 0))+ employment_growth = self.to_decimal(economic_data.get('employment_growth', 0))++ if not stock_returns:+ raise ValidationError("Stock returns data is required")++ # Calculate average stock returns+ avg_stock_return = sum(stock_returns) / self.to_decimal(len(stock_returns))++ # Calculate sustainable growth rate (simplified)+ sustainable_growth = gdp_growth++ # Decompose stock returns+ earnings_growth_component = gdp_growth # Simplified: earnings grow with economy+ dividend_component = dividend_yield+ valuation_change_component = avg_stock_return - earnings_growth_component - dividend_component++ # Analyze long-run relationship+ excess_return = avg_stock_return - sustainable_growth++ return {+ 'average_stock_return': avg_stock_return,+ 'sustainable_growth_rate': sustainable_growth,+ 'excess_return': excess_return,+ 'return_decomposition': {+ 'earnings_growth': earnings_growth_component,+ 'dividend_yield': dividend_component,+ 'valuation_change': valuation_change_component+ },+ 'long_run_relationship': {+ 'description': 'In long run, stock returns should converge to sustainable growth + dividend yield',+ 'theoretical_return': sustainable_growth + dividend_yield,+ 'current_deviation': avg_stock_return - (sustainable_growth + dividend_yield),+ 'sustainable': abs(excess_return) < self.to_decimal(2) # Within 2% considered sustainable+ },+ 'implications_for_investors': self._generate_stock_growth_implications(excess_return, pe_ratio)+ }++ def _generate_stock_growth_implications(self, excess_return: Decimal, pe_ratio: Decimal) -> Dict[str, str]:+ """Generate investment implications from stock-growth relationship"""++ implications = {}++ if excess_return > self.to_decimal(3):+ implications['valuation'] = 'Market may be overvalued relative to economic fundamentals'+ implications['future_returns'] = 'Expected returns may be below historical average'+ implications['risk'] = 'Higher risk of market correction'+ elif excess_return < self.to_decimal(-3):+ implications['valuation'] = 'Market may be undervalued relative to economic fundamentals'+ implications['future_returns'] = 'Expected returns may be above historical average'+ implications['risk'] = 'Potential opportunity for higher returns'+ else:+ implications['valuation'] = 'Market appears fairly valued relative to economic growth'+ implications['future_returns'] = 'Expected returns align with sustainable growth'+ implications['risk'] = 'Balanced risk-return profile'++ # PE ratio implications+ if pe_ratio > self.to_decimal(25):+ implications['pe_signal'] = 'High PE suggests expensive market'+ elif pe_ratio < self.to_decimal(12):+ implications['pe_signal'] = 'Low PE suggests attractive valuations'+ else:+ implications['pe_signal'] = 'PE ratio within normal range'++ return implications++ def potential_gdp_importance(self, gdp_data: Dict[str, Any], investor_type: str) -> Dict[str, Any]:+ """Explain importance of potential GDP for equity and fixed income investors"""++ potential_gdp = self.to_decimal(gdp_data.get('potential_gdp', 0))+ actual_gdp = self.to_decimal(gdp_data.get('actual_gdp', 0))+ potential_growth = self.to_decimal(gdp_data.get('potential_growth_rate', 0))++ # Calculate output gap+ output_gap = ((actual_gdp - potential_gdp) / potential_gdp) * self.to_decimal(100)++ if investor_type.lower() == 'equity':+ return self._equity_investor_implications(output_gap, potential_growth, gdp_data)+ elif investor_type.lower() == 'fixed_income':+ return self._fixed_income_implications(output_gap, potential_growth, gdp_data)+ else:+ # Return both+ return {+ 'equity_implications': self._equity_investor_implications(output_gap, potential_growth, gdp_data),+ 'fixed_income_implications': self._fixed_income_implications(output_gap, potential_growth, gdp_data),+ 'output_gap': output_gap,+ 'potential_growth_rate': potential_growth+ }++ def _equity_investor_implications(self, output_gap: Decimal, potential_growth: Decimal,+ gdp_data: Dict[str, Any]) -> Dict[str, Any]:+ """Implications of potential GDP for equity investors"""++ return {+ 'earnings_growth_potential': {+ 'description': 'Potential GDP growth sets upper bound for long-term earnings growth',+ 'implication': f'Long-term earnings growth limited to ~{potential_growth:.1f}% annually',+ 'current_position': 'Above potential' if output_gap > 0 else 'Below potential'+ },+ 'cyclical_positioning': {+ 'output_gap': output_gap,+ 'interpretation': self._interpret_output_gap_equity(output_gap),+ 'strategy': self._equity_strategy_from_gap(output_gap)+ },+ 'sector_implications': {+ 'cyclical_sectors': 'Sensitive to output gap fluctuations',+ 'defensive_sectors': 'Less sensitive, focus on long-term potential growth',+ 'growth_sectors': 'Beneficiaries of productivity improvements driving potential growth'+ },+ 'valuation_framework': {+ 'sustainable_pe': f'Long-term PE ratios should reflect potential growth of {potential_growth:.1f}%',+ 'cyclical_adjustment': 'Adjust for temporary deviations from potential'+ }+ }++ def _fixed_income_implications(self, output_gap: Decimal, potential_growth: Decimal,+ gdp_data: Dict[str, Any]) -> Dict[str, Any]:+ """Implications of potential GDP for fixed income investors"""++ inflation_rate = self.to_decimal(gdp_data.get('inflation_rate', 0))++ return {+ 'monetary_policy_stance': {+ 'output_gap': output_gap,+ 'policy_implication': self._monetary_policy_from_gap(output_gap),+ 'interest_rate_direction': self._interest_rate_direction(output_gap)+ },+ 'inflation_expectations': {+ 'gap_pressure': 'Positive gap = inflationary pressure' if output_gap > 0 else 'Negative gap = disinflationary pressure',+ 'long_term_anchor': f'Long-term inflation should align with potential growth of {potential_growth:.1f}%',+ 'current_risk': 'Inflation risk elevated' if output_gap > self.to_decimal(+ 2) else 'Inflation risk contained'+ },+ 'yield_curve_implications': {+ 'short_end': 'Driven by central bank response to output gap',+ 'long_end': 'Anchored by potential growth and inflation expectations',+ 'curve_shape': self._yield_curve_shape(output_gap)+ },+ 'credit_risk_assessment': {+ 'corporate_earnings': 'Tied to actual vs potential GDP performance',+ 'default_risk': 'Lower when economy operates near potential',+ 'recovery_rates': 'Higher potential growth supports better recovery values'+ }+ }++ def _interpret_output_gap_equity(self, gap: Decimal) -> str:+ """Interpret output gap for equity investors"""+ if gap > self.to_decimal(2):+ return "Economy overheating - potential for policy tightening and earnings pressure"+ elif gap > self.to_decimal(0):+ return "Economy above potential - supporting earnings but watch for inflation"+ elif gap > self.to_decimal(-2):+ return "Economy near potential - balanced growth environment"+ else:+ return "Economy below potential - room for growth but current earnings pressure"++ def _equity_strategy_from_gap(self, gap: Decimal) -> str:+ """Suggest equity strategy based on output gap"""+ if gap > self.to_decimal(2):+ return "Consider defensive positioning, watch for policy tightening"+ elif gap > self.to_decimal(0):+ return "Balanced approach, favor quality cyclicals"+ else:+ return "Growth opportunities available, consider cyclical exposure"++ def _monetary_policy_from_gap(self, gap: Decimal) -> str:+ """Predict monetary policy stance from output gap"""+ if gap > self.to_decimal(1):+ return "Likely tightening bias"+ elif gap > self.to_decimal(-1):+ return "Neutral stance"+ else:+ return "Likely easing bias"++ def _interest_rate_direction(self, gap: Decimal) -> str:+ """Predict interest rate direction"""+ if gap > self.to_decimal(1):+ return "Upward pressure"+ elif gap > self.to_decimal(-1):+ return "Stable"+ else:+ return "Downward pressure"++ def _yield_curve_shape(self, gap: Decimal) -> str:+ """Predict yield curve shape"""+ if gap > self.to_decimal(2):+ return "Flattening risk (short rates rising faster)"+ elif gap < self.to_decimal(-2):+ return "Steepening (short rates falling faster)"+ else:+ return "Stable shape"++ def forecast_potential_gdp(self, historical_data: Dict[str, Any],+ forecast_assumptions: Dict[str, Any]) -> Dict[str, Any]:+ """Forecast potential GDP using growth accounting relations"""++ # Historical data+ labor_force_growth = [self.to_decimal(x) for x in historical_data.get('labor_force_growth', [])]+ productivity_growth = [self.to_decimal(x) for x in historical_data.get('productivity_growth', [])]+ capital_growth = [self.to_decimal(x) for x in historical_data.get('capital_growth', [])]++ # Forecast assumptions+ forecast_periods = int(forecast_assumptions.get('periods', 5))+ labor_growth_forecast = self.to_decimal(forecast_assumptions.get('labor_growth_rate', 0))+ productivity_growth_forecast = self.to_decimal(forecast_assumptions.get('productivity_growth_rate', 0))+ capital_growth_forecast = self.to_decimal(forecast_assumptions.get('capital_growth_rate', 0))++ # Growth accounting: Y = A * K^α * L^(1-α)+ # Growth rate: g_Y = g_A + α * g_K + (1-α) * g_L+ alpha = self.to_decimal(forecast_assumptions.get('capital_share', 0.3)) # Capital's share of output++ # Calculate historical potential growth+ historical_potential = []+ min_length = min(len(labor_force_growth), len(productivity_growth), len(capital_growth))++ for i in range(min_length):+ potential_growth = (productivity_growth[i] ++ alpha * capital_growth[i] ++ (self.to_decimal(1) - alpha) * labor_force_growth[i])+ historical_potential.append(potential_growth)++ # Forecast potential GDP growth+ forecast_potential_growth = (productivity_growth_forecast ++ alpha * capital_growth_forecast ++ (self.to_decimal(1) - alpha) * labor_growth_forecast)++ # Calculate trend components+ trend_productivity = sum(productivity_growth) / self.to_decimal(+ len(productivity_growth)) if productivity_growth else self.to_decimal(0)+ trend_labor = sum(labor_force_growth) / self.to_decimal(+ len(labor_force_growth)) if labor_force_growth else self.to_decimal(0)+ trend_capital = sum(capital_growth) / self.to_decimal(+ len(capital_growth)) if capital_growth else self.to_decimal(0)++ return {+ 'growth_accounting_framework': {+ 'formula': 'GDP Growth = Productivity Growth + α×Capital Growth + (1-α)×Labor Growth',+ 'capital_share_alpha': alpha,+ 'labor_share': self.to_decimal(1) - alpha+ },+ 'historical_analysis': {+ 'historical_potential_growth': historical_potential,+ 'average_historical_potential': sum(historical_potential) / self.to_decimal(+ len(historical_potential)) if historical_potential else self.to_decimal(0),+ 'trend_components': {+ 'productivity': trend_productivity,+ 'labor_force': trend_labor,+ 'capital_stock': trend_capital+ }+ },+ 'forecast': {+ 'periods': forecast_periods,+ 'potential_gdp_growth': forecast_potential_growth,+ 'components': {+ 'productivity_contribution': productivity_growth_forecast,+ 'capital_contribution': alpha * capital_growth_forecast,+ 'labor_contribution': (self.to_decimal(1) - alpha) * labor_growth_forecast+ },+ 'assumptions': forecast_assumptions+ },+ 'sensitivity_analysis': self._sensitivity_analysis_potential_gdp(+ alpha, productivity_growth_forecast, capital_growth_forecast, labor_growth_forecast+ )+ }++ def _sensitivity_analysis_potential_gdp(self, alpha: Decimal, prod_growth: Decimal,+ cap_growth: Decimal, lab_growth: Decimal) -> Dict[str, Any]:+ """Sensitivity analysis for potential GDP forecast"""++ base_growth = prod_growth + alpha * cap_growth + (self.to_decimal(1) - alpha) * lab_growth++ # Test scenarios+ scenarios = {+ 'productivity_high': prod_growth + self.to_decimal(0.005), # +0.5pp+ 'productivity_low': prod_growth - self.to_decimal(0.005), # -0.5pp+ 'capital_high': cap_growth + self.to_decimal(0.01), # +1pp+ 'capital_low': cap_growth - self.to_decimal(0.01), # -1pp+ 'labor_high': lab_growth + self.to_decimal(0.005), # +0.5pp+ 'labor_low': lab_growth - self.to_decimal(0.005) # -0.5pp+ }++ sensitivity_results = {}+ for scenario, value in scenarios.items():+ if 'productivity' in scenario:+ new_growth = value + alpha * cap_growth + (self.to_decimal(1) - alpha) * lab_growth+ elif 'capital' in scenario:+ new_growth = prod_growth + alpha * value + (self.to_decimal(1) - alpha) * lab_growth+ else: # labor scenario+ new_growth = prod_growth + alpha * cap_growth + (self.to_decimal(1) - alpha) * value++ sensitivity_results[scenario] = {+ 'growth_rate': new_growth,+ 'change_from_base': new_growth - base_growth+ }++ return {+ 'base_case': base_growth,+ 'scenarios': sensitivity_results,+ 'most_sensitive_to': max(sensitivity_results.items(),+ key=lambda x: abs(x[1]['change_from_base']))[0]+ }++ def calculate(self, analysis_type: str, **kwargs) -> Dict[str, Any]:+ """Main calculation dispatcher"""++ calculations = {+ 'growth_factors': lambda: self.compare_growth_factors(+ kwargs['country_type'], kwargs['economic_data']+ ),+ 'stock_growth_relationship': lambda: self.analyze_stock_market_growth_relationship(+ kwargs['market_data'], kwargs['economic_data']+ ),+ 'potential_gdp_importance': lambda: self.potential_gdp_importance(+ kwargs['gdp_data'], kwargs.get('investor_type', 'both')+ ),+ 'forecast_potential_gdp': lambda: self.forecast_potential_gdp(+ kwargs['historical_data'], kwargs['forecast_assumptions']+ )+ }++ if analysis_type not in calculations:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = calculations[analysis_type]()+ result['metadata'] = self.get_metadata()+ result['analysis_type'] = analysis_type++ return result+++class ProductivityAnalyzer(EconomicsBase):+ """Capital deepening vs technological progress analysis"""++ def analyze_capital_deepening_vs_technology(self, productivity_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze effects of capital deepening vs technological progress"""++ # Extract data+ capital_per_worker = self.to_decimal(productivity_data.get('capital_per_worker_growth', 0))+ total_factor_productivity = self.to_decimal(productivity_data.get('tfp_growth', 0))+ labor_productivity = self.to_decimal(productivity_data.get('labor_productivity_growth', 0))++ # Production function: Y = A * K^α * L^(1-α)+ # Labor productivity: Y/L = A * (K/L)^α+ # Growth: g(Y/L) = g(A) + α * g(K/L)++ alpha = self.to_decimal(0.3) # Typical capital share++ # Decompose labor productivity growth+ capital_deepening_contribution = alpha * capital_per_worker+ technology_contribution = total_factor_productivity++ # Verify decomposition+ implied_productivity_growth = capital_deepening_contribution + technology_contribution+ residual = labor_productivity - implied_productivity_growth++ return {+ 'decomposition': {+ 'labor_productivity_growth': labor_productivity,+ 'capital_deepening_contribution': capital_deepening_contribution,+ 'technology_contribution': technology_contribution,+ 'residual': residual+ },+ 'relative_importance': {+ 'capital_deepening_share': (capital_deepening_contribution / labor_productivity * self.to_decimal(+ 100)) if labor_productivity != 0 else self.to_decimal(0),+ 'technology_share': (technology_contribution / labor_productivity * self.to_decimal(+ 100)) if labor_productivity != 0 else self.to_decimal(0)+ },+ 'economic_implications': {+ 'capital_deepening': {+ 'description': 'Increasing capital per worker',+ 'effects': 'Diminishing returns, temporary boost to productivity',+ 'sustainability': 'Limited by diminishing marginal returns',+ 'policy_focus': 'Investment incentives, savings rates'+ },+ 'technological_progress': {+ 'description': 'Improvements in total factor productivity',+ 'effects': 'Sustainable productivity gains, no diminishing returns',+ 'sustainability': 'Can sustain long-term growth',+ 'policy_focus': 'R&D investment, education, innovation'+ }+ },+ 'growth_sustainability': self._assess_growth_sustainability(+ capital_deepening_contribution, technology_contribution+ )+ }++ def _assess_growth_sustainability(self, capital_contrib: Decimal, tech_contrib: Decimal) -> Dict[str, Any]:+ """Assess sustainability of growth based on contributions"""++ total_contrib = capital_contrib + tech_contrib++ if total_contrib == 0:+ return {'assessment': 'No productivity growth', 'sustainability': 'Poor'}++ tech_share = tech_contrib / total_contrib++ if tech_share > self.to_decimal(0.7):+ sustainability = 'High'+ assessment = 'Technology-driven growth is highly sustainable'+ elif tech_share > self.to_decimal(0.4):+ sustainability = 'Moderate'+ assessment = 'Balanced growth with good sustainability prospects'+ else:+ sustainability = 'Low'+ assessment = 'Capital-dependent growth faces diminishing returns'++ return {+ 'assessment': assessment,+ 'sustainability': sustainability,+ 'technology_share': tech_share * self.to_decimal(100),+ 'recommendations': self._generate_sustainability_recommendations(tech_share)+ }++ def _generate_sustainability_recommendations(self, tech_share: Decimal) -> List[str]:+ """Generate recommendations based on technology share"""++ recommendations = []++ if tech_share < self.to_decimal(0.3):+ recommendations.extend([+ 'Increase R&D spending to boost technological progress',+ 'Invest in education and human capital development',+ 'Encourage innovation through patent protection and incentives',+ 'Reduce reliance on pure capital accumulation'+ ])+ elif tech_share < self.to_decimal(0.6):+ recommendations.extend([+ 'Maintain balanced approach to capital and technology',+ 'Continue investing in both physical and human capital',+ 'Focus on technology transfer and adoption'+ ])+ else:+ recommendations.extend([+ 'Sustain high-technology focus',+ 'Ensure adequate capital to complement technology',+ 'Maintain competitive advantage in innovation'+ ])++ return recommendations++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate productivity analysis"""+ return self.analyze_capital_deepening_vs_technology(kwargs['productivity_data'])+++class ConvergenceAnalyzer(EconomicsBase):+ """Economic convergence hypotheses analysis"""++ def test_convergence_hypotheses(self, country_data: List[Dict[str, Any]],+ convergence_type: str = 'beta') -> Dict[str, Any]:+ """Test convergence hypotheses (beta and sigma convergence)"""++ if convergence_type not in ['beta', 'sigma', 'both']:+ raise ValidationError("Convergence type must be 'beta', 'sigma', or 'both'")++ results = {}++ if convergence_type in ['beta', 'both']:+ results['beta_convergence'] = self._test_beta_convergence(country_data)++ if convergence_type in ['sigma', 'both']:+ results['sigma_convergence'] = self._test_sigma_convergence(country_data)++ results['convergence_theories'] = self._explain_convergence_theories()++ return results++ def _test_beta_convergence(self, country_data: List[Dict[str, Any]]) -> Dict[str, Any]:+ """Test beta convergence (catch-up effect)"""++ # Extract initial GDP per capita and growth rates+ initial_gdp = []+ growth_rates = []++ for country in country_data:+ initial_gdp.append(self.to_decimal(country['initial_gdp_per_capita']))+ growth_rates.append(self.to_decimal(country['avg_growth_rate']))++ if len(initial_gdp) < 3:+ raise ValidationError("At least 3 countries required for convergence analysis")++ # Simple correlation analysis (in practice would use regression)+ # Beta convergence: negative correlation between initial GDP and growth+ correlation = self._calculate_correlation(initial_gdp, growth_rates)++ convergence_speed = -correlation * self.to_decimal(0.02) # Simplified speed calculation+ half_life = self.to_decimal(0.693) / abs(convergence_speed) if convergence_speed != 0 else None++ return {+ 'correlation_coefficient': correlation,+ 'convergence_exists': correlation < self.to_decimal(-0.3),+ 'convergence_speed': convergence_speed,+ 'half_life_years': half_life,+ 'interpretation': self._interpret_beta_convergence(correlation),+ 'countries_analyzed': len(country_data)+ }++ def _test_sigma_convergence(self, country_data: List[Dict[str, Any]]) -> Dict[str, Any]:+ """Test sigma convergence (dispersion reduction)"""++ # Extract GDP per capita over time+ time_periods = {}++ for country in country_data:+ for year, gdp in country.get('gdp_time_series', {}).items():+ if year not in time_periods:+ time_periods[year] = []+ time_periods[year].append(self.to_decimal(gdp))++ # Calculate standard deviation over time+ dispersions = {}+ for year, gdp_values in time_periods.items():+ if len(gdp_values) > 1:+ mean_gdp = sum(gdp_values) / self.to_decimal(len(gdp_values))+ variance = sum((x - mean_gdp) ** 2 for x in gdp_values) / self.to_decimal(len(gdp_values) - 1)+ dispersions[year] = variance.sqrt()++ # Check if dispersion is decreasing+ years = sorted(dispersions.keys())+ if len(years) < 2:+ raise ValidationError("At least 2 time periods required for sigma convergence")++ initial_dispersion = dispersions[years[0]]+ final_dispersion = dispersions[years[-1]]+ dispersion_change = (final_dispersion - initial_dispersion) / initial_dispersion++ return {+ 'initial_dispersion': initial_dispersion,+ 'final_dispersion': final_dispersion,+ 'dispersion_change_percent': dispersion_change * self.to_decimal(100),+ 'sigma_convergence_exists': final_dispersion < initial_dispersion,+ 'time_periods_analyzed': len(years),+ 'dispersion_trend': 'Decreasing' if final_dispersion < initial_dispersion else 'Increasing'+ }++ def _calculate_correlation(self, x_values: List[Decimal], y_values: List[Decimal]) -> Decimal:+ """Calculate correlation coefficient"""+ n = len(x_values)+ if n != len(y_values) or n < 2:+ return self.to_decimal(0)++ mean_x = sum(x_values) / self.to_decimal(n)+ mean_y = sum(y_values) / self.to_decimal(n)++ numerator = sum((x_values[i] - mean_x) * (y_values[i] - mean_y) for i in range(n))++ sum_sq_x = sum((x - mean_x) ** 2 for x in x_values)+ sum_sq_y = sum((y - mean_y) ** 2 for y in y_values)++ denominator = (sum_sq_x * sum_sq_y).sqrt()++ return numerator / denominator if denominator != 0 else self.to_decimal(0)++ def _interpret_beta_convergence(self, correlation: Decimal) -> str:+ """Interpret beta convergence results"""+ if correlation < self.to_decimal(-0.5):+ return "Strong beta convergence: Poor countries growing significantly faster"+ elif correlation < self.to_decimal(-0.3):+ return "Moderate beta convergence: Some catch-up effect observed"+ elif correlation < self.to_decimal(-0.1):+ return "Weak beta convergence: Limited catch-up effect"+ else:+ return "No beta convergence: No systematic catch-up by poor countries"++ def _explain_convergence_theories(self) -> Dict[str, Any]:+ """Explain convergence theories"""+ return {+ 'neoclassical_theory': {+ 'prediction': 'Unconditional convergence due to diminishing returns',+ 'mechanism': 'Poor countries have higher marginal returns to capital',+ 'assumptions': 'Same technology, preferences, institutions',+ 'reality': 'Limited empirical support for unconditional convergence'+ },+ 'conditional_convergence': {+ 'prediction': 'Convergence to country-specific steady states',+ 'mechanism': 'Countries converge to own equilibrium based on fundamentals',+ 'factors': 'Savings rates, population growth, technology, institutions',+ 'evidence': 'Stronger empirical support'+ },+ 'endogenous_growth': {+ 'prediction': 'Divergence possible due to increasing returns',+ 'mechanism': 'Knowledge spillovers, human capital externalities',+ 'implications': 'Rich countries may grow faster permanently',+ 'policy': 'Government intervention may be needed'+ }+ }++ def calculate(self, convergence_type: str = 'both', **kwargs) -> Dict[str, Any]:+ """Calculate convergence analysis"""+ return self.test_convergence_hypotheses(kwargs['country_data'], convergence_type)+++class DemographicAnalyzer(EconomicsBase):+ """Demographics, immigration, and labor force participation analysis"""++ def analyze_demographic_impact(self, demographic_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze how demographics affect economic growth"""++ # Extract demographic data+ population_growth = self.to_decimal(demographic_data.get('population_growth_rate', 0))+ working_age_share = self.to_decimal(demographic_data.get('working_age_population_share', 0))+ dependency_ratio = self.to_decimal(demographic_data.get('dependency_ratio', 0))+ life_expectancy = self.to_decimal(demographic_data.get('life_expectancy', 0))+ fertility_rate = self.to_decimal(demographic_data.get('fertility_rate', 0))++ # Immigration data+ immigration_rate = self.to_decimal(demographic_data.get('net_immigration_rate', 0))+ immigrant_age_profile = demographic_data.get('immigrant_avg_age', 30)++ # Labor force data+ labor_force_participation = self.to_decimal(demographic_data.get('labor_force_participation_rate', 0))+ female_participation = self.to_decimal(demographic_data.get('female_labor_participation', 0))++ return {+ 'demographic_dividend_analysis': self._analyze_demographic_dividend(+ working_age_share, dependency_ratio, population_growth+ ),+ 'immigration_impact': self._analyze_immigration_impact(+ immigration_rate, immigrant_age_profile, labor_force_participation+ ),+ 'labor_force_dynamics': self._analyze_labor_force_participation(+ labor_force_participation, female_participation, working_age_share+ ),+ 'long_term_sustainability': self._assess_demographic_sustainability(+ fertility_rate, life_expectancy, dependency_ratio+ ),+ 'policy_implications': self._generate_demographic_policy_recommendations(+ fertility_rate, dependency_ratio, immigration_rate, female_participation+ )+ }++ def _analyze_demographic_dividend(self, working_age_share: Decimal,+ dependency_ratio: Decimal, pop_growth: Decimal) -> Dict[str, Any]:+ """Analyze demographic dividend potential"""++ # Demographic dividend occurs when working age population grows faster than dependents+ dividend_potential = working_age_share / dependency_ratio if dependency_ratio > 0 else self.to_decimal(0)++ if working_age_share > self.to_decimal(65) and dependency_ratio < self.to_decimal(50):+ dividend_stage = "Peak dividend period"+ growth_impact = "High positive impact on growth"+ elif working_age_share > self.to_decimal(60):+ dividend_stage = "Dividend period"+ growth_impact = "Positive impact on growth"+ elif working_age_share < self.to_decimal(55):+ dividend_stage = "Post-dividend or pre-dividend"+ growth_impact = "Limited or negative growth impact"+ else:+ dividend_stage = "Transition period"+ growth_impact = "Moderate growth impact"++ return {+ 'working_age_share': working_age_share,+ 'dependency_ratio': dependency_ratio,+ 'dividend_potential_score': dividend_potential,+ 'dividend_stage': dividend_stage,+ 'growth_impact': growth_impact,+ 'duration_estimate': self._estimate_dividend_duration(working_age_share, pop_growth),+ 'policy_window': "15-30 years to capitalize on demographic dividend"+ }++ def _analyze_immigration_impact(self, immigration_rate: Decimal,+ avg_age: float, lfpr: Decimal) -> Dict[str, Any]:+ """Analyze immigration impact on growth"""++ # Young immigrants have higher growth impact+ age_factor = max(self.to_decimal(0), self.to_decimal(50 - avg_age) / self.to_decimal(20))++ # Immigration impact on labor force+ labor_force_boost = immigration_rate * lfpr / self.to_decimal(100)++ # Fiscal impact (simplified)+ if avg_age < 35:+ fiscal_impact = "Positive (young workers, long contribution period)"+ elif avg_age < 50:+ fiscal_impact = "Neutral to positive"+ else:+ fiscal_impact = "Potentially negative (shorter contribution period)"++ return {+ 'immigration_rate': immigration_rate,+ 'average_immigrant_age': avg_age,+ 'age_factor_score': age_factor,+ 'labor_force_contribution': labor_force_boost,+ 'fiscal_impact_assessment': fiscal_impact,+ 'skill_considerations': "High-skilled immigration provides greater growth benefits",+ 'integration_factors': "Language, credential recognition affect productivity"+ }++ def _analyze_labor_force_participation(self, overall_lfpr: Decimal,+ female_lfpr: Decimal, working_age_share: Decimal) -> Dict[str, Any]:+ """Analyze labor force participation trends"""++ # Potential labor force growth from increased participation+ max_lfpr = self.to_decimal(85) # Realistic maximum+ participation_gap = max_lfpr - overall_lfpr++ # Female participation potential (often lower than male)+ female_potential = self.to_decimal(80) - female_lfpr # Assuming male rate ~85%++ return {+ 'current_participation_rate': overall_lfpr,+ 'female_participation_rate': female_lfpr,+ 'participation_gap': participation_gap,+ 'female_participation_potential': female_potential,+ 'growth_potential_from_participation': participation_gap * working_age_share / self.to_decimal(100),+ 'policy_levers': [+ 'Childcare support to increase female participation',+ 'Flexible work arrangements',+ 'Education and skills training',+ 'Retirement age adjustments for aging societies'+ ]+ }++ def _assess_demographic_sustainability(self, fertility_rate: Decimal,+ life_expectancy: Decimal, dependency_ratio: Decimal) -> Dict[str, Any]:+ """Assess long-term demographic sustainability"""++ replacement_rate = self.to_decimal(2.1) # Fertility rate needed for population stability++ if fertility_rate < self.to_decimal(1.5):+ sustainability_level = "Low - Population decline likely"+ policy_urgency = "High"+ elif fertility_rate < replacement_rate:+ sustainability_level = "Moderate - Below replacement rate"+ policy_urgency = "Medium"+ else:+ sustainability_level = "High - Above replacement rate"+ policy_urgency = "Low"++ # Aging challenge+ if dependency_ratio > self.to_decimal(60):+ aging_challenge = "Severe aging burden"+ elif dependency_ratio > self.to_decimal(45):+ aging_challenge = "Moderate aging challenge"+ else:+ aging_challenge = "Manageable dependency ratio"++ return {+ 'fertility_rate': fertility_rate,+ 'replacement_rate': replacement_rate,+ 'fertility_gap': fertility_rate - replacement_rate,+ 'life_expectancy': life_expectancy,+ 'dependency_ratio': dependency_ratio,+ 'sustainability_assessment': sustainability_level,+ 'aging_challenge': aging_challenge,+ 'policy_urgency': policy_urgency,+ 'time_horizon': "Demographic changes take 20-30 years to materialize"+ }++ def _estimate_dividend_duration(self, working_age_share: Decimal, pop_growth: Decimal) -> str:+ """Estimate demographic dividend duration"""+ if working_age_share > self.to_decimal(65):+ return "10-20 years remaining"+ elif working_age_share > self.to_decimal(60):+ return "20-30 years remaining"+ else:+ return "Dividend period ending or not yet started"++ def _generate_demographic_policy_recommendations(self, fertility_rate: Decimal,+ dependency_ratio: Decimal,+ immigration_rate: Decimal,+ female_lfpr: Decimal) -> List[str]:+ """Generate policy recommendations based on demographic profile"""++ recommendations = []++ # Fertility-based recommendations+ if fertility_rate < self.to_decimal(1.8):+ recommendations.extend([+ 'Implement family-friendly policies (parental leave, childcare)',+ 'Provide financial incentives for families',+ 'Improve work-life balance policies'+ ])++ # Aging-based recommendations+ if dependency_ratio > self.to_decimal(50):+ recommendations.extend([+ 'Gradually increase retirement age',+ 'Reform pension systems for sustainability',+ 'Invest in elderly care infrastructure'+ ])++ # Immigration recommendations+ if immigration_rate < self.to_decimal(0.5) and dependency_ratio > self.to_decimal(45):+ recommendations.extend([+ 'Develop skilled immigration programs',+ 'Improve integration services',+ 'Streamline immigration processes'+ ])++ # Female participation recommendations+ if female_lfpr < self.to_decimal(70):+ recommendations.extend([+ 'Expand affordable childcare',+ 'Promote flexible work arrangements',+ 'Address gender wage gaps'+ ])++ return recommendations++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate demographic analysis"""+ return self.analyze_demographic_impact(kwargs['demographic_data'])\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/market_cycles.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/market_cycles.pynew file mode 100644index 000000000..350ad5973--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/market_cycles.py@@ -0,0 +1,1003 @@++Economic Market Cycles Module+=============================++Business cycle identification and analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++from decimal import Decimal+from typing import Dict, List, Tuple, Optional, Any, Union+from datetime import datetime, timedelta+import pandas as pd+import numpy as np+from .core import EconomicsBase, ValidationError, CalculationError, DataError+++class BusinessCycleAnalyzer(EconomicsBase):+ """Business cycle phases and economic indicator analysis"""++ def __init__(self, precision: int = 8, base_currency: str = 'USD'):+ super().__init__(precision, base_currency)+ self.cycle_phases = ['expansion', 'peak', 'contraction', 'trough']++ def detect_cycle_phase(self, economic_indicators: Dict[str, Any]) -> Dict[str, Any]:+ """Detect current business cycle phase based on economic indicators"""++ # Extract key indicators+ gdp_growth = self.to_decimal(economic_indicators.get('gdp_growth_rate', 0))+ unemployment_rate = self.to_decimal(economic_indicators.get('unemployment_rate', 0))+ inflation_rate = self.to_decimal(economic_indicators.get('inflation_rate', 0))+ interest_rates = self.to_decimal(economic_indicators.get('interest_rate', 0))+ consumer_confidence = self.to_decimal(economic_indicators.get('consumer_confidence', 0))+ business_investment = self.to_decimal(economic_indicators.get('business_investment_growth', 0))++ # Phase detection scoring+ phase_scores = self._calculate_phase_scores(+ gdp_growth, unemployment_rate, inflation_rate,+ interest_rates, consumer_confidence, business_investment+ )++ # Determine most likely phase+ detected_phase = max(phase_scores.items(), key=lambda x: x[1]['score'])[0]++ return {+ 'detected_phase': detected_phase,+ 'phase_scores': phase_scores,+ 'confidence_level': phase_scores[detected_phase]['score'],+ 'indicator_analysis': self._analyze_indicators_by_phase(economic_indicators),+ 'phase_characteristics': self._get_phase_characteristics(detected_phase),+ 'expected_duration': self._estimate_phase_duration(detected_phase, economic_indicators),+ 'investment_implications': self._get_investment_implications(detected_phase)+ }++ def _calculate_phase_scores(self, gdp_growth: Decimal, unemployment: Decimal,+ inflation: Decimal, interest_rate: Decimal,+ consumer_conf: Decimal, investment: Decimal) -> Dict[str, Any]:+ """Calculate likelihood scores for each business cycle phase"""++ scores = {}++ # Expansion phase indicators+ expansion_score = self.to_decimal(0)+ if gdp_growth > self.to_decimal(2): expansion_score += self.to_decimal(25)+ if unemployment < self.to_decimal(6): expansion_score += self.to_decimal(20)+ if consumer_conf > self.to_decimal(100): expansion_score += self.to_decimal(20)+ if investment > self.to_decimal(3): expansion_score += self.to_decimal(20)+ if inflation > self.to_decimal(1) and inflation < self.to_decimal(4): expansion_score += self.to_decimal(15)++ scores['expansion'] = {+ 'score': expansion_score,+ 'indicators': 'Positive GDP growth, low unemployment, high confidence'+ }++ # Peak phase indicators+ peak_score = self.to_decimal(0)+ if gdp_growth > self.to_decimal(1) and gdp_growth < self.to_decimal(3): peak_score += self.to_decimal(15)+ if unemployment < self.to_decimal(4): peak_score += self.to_decimal(25)+ if inflation > self.to_decimal(3): peak_score += self.to_decimal(25)+ if interest_rate > self.to_decimal(4): peak_score += self.to_decimal(20)+ if consumer_conf > self.to_decimal(110): peak_score += self.to_decimal(15)++ scores['peak'] = {+ 'score': peak_score,+ 'indicators': 'Slowing growth, very low unemployment, rising inflation'+ }++ # Contraction phase indicators+ contraction_score = self.to_decimal(0)+ if gdp_growth < self.to_decimal(0): contraction_score += self.to_decimal(30)+ if unemployment > self.to_decimal(7): contraction_score += self.to_decimal(25)+ if consumer_conf < self.to_decimal(90): contraction_score += self.to_decimal(20)+ if investment < self.to_decimal(0): contraction_score += self.to_decimal(25)++ scores['contraction'] = {+ 'score': contraction_score,+ 'indicators': 'Negative GDP growth, rising unemployment, low confidence'+ }++ # Trough phase indicators+ trough_score = self.to_decimal(0)+ if gdp_growth > self.to_decimal(-1) and gdp_growth < self.to_decimal(1): trough_score += self.to_decimal(20)+ if unemployment > self.to_decimal(8): trough_score += self.to_decimal(25)+ if inflation < self.to_decimal(2): trough_score += self.to_decimal(20)+ if interest_rate < self.to_decimal(3): trough_score += self.to_decimal(20)+ if consumer_conf < self.to_decimal(85): trough_score += self.to_decimal(15)++ scores['trough'] = {+ 'score': trough_score,+ 'indicators': 'Stabilizing negative growth, high unemployment, low rates'+ }++ return scores++ def _analyze_indicators_by_phase(self, indicators: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze how different economic indicators vary over business cycle"""++ return {+ 'leading_indicators': {+ 'description': 'Change before the economy changes direction',+ 'examples': {+ 'stock_market': indicators.get('stock_market_performance', 'N/A'),+ 'consumer_confidence': indicators.get('consumer_confidence', 'N/A'),+ 'new_business_formation': indicators.get('new_business_starts', 'N/A'),+ 'yield_curve': indicators.get('yield_curve_slope', 'N/A')+ },+ 'investment_utility': 'Most valuable for timing market entry/exit'+ },+ 'coincident_indicators': {+ 'description': 'Change at the same time as the economy',+ 'examples': {+ 'gdp_growth': indicators.get('gdp_growth_rate', 'N/A'),+ 'employment': indicators.get('employment_rate', 'N/A'),+ 'industrial_production': indicators.get('industrial_production', 'N/A'),+ 'retail_sales': indicators.get('retail_sales_growth', 'N/A')+ },+ 'investment_utility': 'Confirm current economic state'+ },+ 'lagging_indicators': {+ 'description': 'Change after the economy has changed direction',+ 'examples': {+ 'unemployment_rate': indicators.get('unemployment_rate', 'N/A'),+ 'inflation_rate': indicators.get('inflation_rate', 'N/A'),+ 'interest_rates': indicators.get('interest_rate', 'N/A'),+ 'corporate_profits': indicators.get('corporate_profit_growth', 'N/A')+ },+ 'investment_utility': 'Confirm cycle turning points after the fact'+ }+ }++ def _get_phase_characteristics(self, phase: str) -> Dict[str, Any]:+ """Get detailed characteristics of each business cycle phase"""++ characteristics = {+ 'expansion': {+ 'duration': '2-8 years typically',+ 'gdp_growth': 'Positive and accelerating',+ 'unemployment': 'Declining',+ 'inflation': 'Gradually rising',+ 'interest_rates': 'Rising as central bank tightens',+ 'business_activity': 'Increasing investment, hiring, capacity utilization',+ 'consumer_behavior': 'Rising confidence, increased spending',+ 'financial_markets': 'Stock markets generally rising, credit expanding'+ },+ 'peak': {+ 'duration': 'Brief period (months)',+ 'gdp_growth': 'Positive but slowing',+ 'unemployment': 'At cyclical lows',+ 'inflation': 'At or near cyclical highs',+ 'interest_rates': 'At cyclical highs',+ 'business_activity': 'Capacity constraints, labor shortages',+ 'consumer_behavior': 'High confidence but spending slowing',+ 'financial_markets': 'Stock markets vulnerable, tight credit'+ },+ 'contraction': {+ 'duration': '6 months to 2 years',+ 'gdp_growth': 'Negative for at least 2 quarters',+ 'unemployment': 'Rising sharply',+ 'inflation': 'Falling due to weak demand',+ 'interest_rates': 'Falling as central bank eases',+ 'business_activity': 'Declining investment, layoffs, low capacity use',+ 'consumer_behavior': 'Falling confidence, reduced spending',+ 'financial_markets': 'Bear markets, credit contraction'+ },+ 'trough': {+ 'duration': 'Brief period (months)',+ 'gdp_growth': 'Negative but stabilizing',+ 'unemployment': 'At cyclical highs but stabilizing',+ 'inflation': 'Low and stable',+ 'interest_rates': 'At cyclical lows',+ 'business_activity': 'Excess capacity, cautious investment',+ 'consumer_behavior': 'Low confidence but stabilizing',+ 'financial_markets': 'Markets often bottom before economy'+ }+ }++ return characteristics.get(phase, {})++ def _estimate_phase_duration(self, phase: str, indicators: Dict[str, Any]) -> str:+ """Estimate remaining duration of current phase"""++ phase_durations = {+ 'expansion': 'Typically 2-8 years; current strength suggests 1-3 years remaining',+ 'peak': 'Brief transition period; 3-12 months before contraction begins',+ 'contraction': 'Typically 6-18 months; depth indicates 6-12 months remaining',+ 'trough': 'Brief transition period; recovery likely within 3-9 months'+ }++ return phase_durations.get(phase, 'Duration uncertain')++ def _get_investment_implications(self, phase: str) -> Dict[str, Any]:+ """Get investment implications for each business cycle phase"""++ implications = {+ 'expansion': {+ 'equity_strategy': 'Favor cyclical stocks, growth sectors',+ 'fixed_income': 'Shorter duration, higher yield focus',+ 'sectors_to_favor': ['Technology', 'Consumer Discretionary', 'Industrials'],+ 'sectors_to_avoid': ['Utilities', 'Consumer Staples'],+ 'overall_risk': 'Moderate to High'+ },+ 'peak': {+ 'equity_strategy': 'Defensive positioning, quality focus',+ 'fixed_income': 'Extend duration, prepare for rate cuts',+ 'sectors_to_favor': ['Healthcare', 'Consumer Staples', 'Utilities'],+ 'sectors_to_avoid': ['Cyclicals', 'Small caps'],+ 'overall_risk': 'Reduce risk exposure'+ },+ 'contraction': {+ 'equity_strategy': 'Defensive stocks, dividend focus',+ 'fixed_income': 'High quality bonds, government securities',+ 'sectors_to_favor': ['Consumer Staples', 'Healthcare', 'Utilities'],+ 'sectors_to_avoid': ['Financials', 'Materials', 'Energy'],+ 'overall_risk': 'Low risk, capital preservation'+ },+ 'trough': {+ 'equity_strategy': 'Prepare for cyclical recovery, value opportunities',+ 'fixed_income': 'Shorten duration, prepare for rate rises',+ 'sectors_to_favor': ['Financials', 'Technology', 'Industrials'],+ 'sectors_to_avoid': ['Defensive sectors becoming expensive'],+ 'overall_risk': 'Gradually increase risk'+ }+ }++ return implications.get(phase, {})++ def analyze_sector_cyclicality(self, sector_data: Dict[str, List[Decimal]]) -> Dict[str, Any]:+ """Analyze how different sectors vary over business cycle"""++ sector_analysis = {}++ for sector, performance_data in sector_data.items():+ if len(performance_data) < 4:+ continue++ # Calculate volatility and correlation with cycle+ volatility = self._calculate_volatility(performance_data)++ # Classify sector cyclicality+ if volatility > self.to_decimal(20):+ cyclicality = 'Highly Cyclical'+ characteristics = 'Large swings with economic cycle'+ elif volatility > self.to_decimal(12):+ cyclicality = 'Moderately Cyclical'+ characteristics = 'Moderate sensitivity to economic changes'+ else:+ cyclicality = 'Defensive'+ characteristics = 'Stable performance through cycles'++ sector_analysis[sector] = {+ 'volatility': volatility,+ 'cyclicality': cyclicality,+ 'characteristics': characteristics,+ 'investment_timing': self._get_sector_timing(cyclicality)+ }++ return {+ 'sector_analysis': sector_analysis,+ 'summary': self._summarize_sector_cyclicality(sector_analysis)+ }++ def _calculate_volatility(self, data: List[Decimal]) -> Decimal:+ """Calculate volatility of performance data"""+ if len(data) < 2:+ return self.to_decimal(0)++ mean = sum(data) / self.to_decimal(len(data))+ variance = sum((x - mean) ** 2 for x in data) / self.to_decimal(len(data) - 1)+ return (variance.sqrt() * self.to_decimal(100)) # As percentage++ def _get_sector_timing(self, cyclicality: str) -> str:+ """Get optimal timing for sector investment"""+ timing_guide = {+ 'Highly Cyclical': 'Buy at trough, sell at peak',+ 'Moderately Cyclical': 'Overweight in expansion, underweight in contraction',+ 'Defensive': 'Stable allocation, overweight during uncertainty'+ }+ return timing_guide.get(cyclicality, 'Standard allocation')++ def _summarize_sector_cyclicality(self, analysis: Dict[str, Any]) -> Dict[str, Any]:+ """Summarize sector cyclicality analysis"""++ cyclical_count = sum(1 for sector in analysis.values()+ if 'Cyclical' in sector['cyclicality'])+ defensive_count = len(analysis) - cyclical_count++ return {+ 'total_sectors_analyzed': len(analysis),+ 'cyclical_sectors': cyclical_count,+ 'defensive_sectors': defensive_count,+ 'portfolio_implication': 'Balance cyclical and defensive based on cycle phase'+ }++ def calculate(self, analysis_type: str = 'phase_detection', **kwargs) -> Dict[str, Any]:+ """Main business cycle calculation dispatcher"""++ if analysis_type == 'phase_detection':+ return self.detect_cycle_phase(kwargs['economic_indicators'])+ elif analysis_type == 'sector_cyclicality':+ return self.analyze_sector_cyclicality(kwargs['sector_data'])+ else:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")+++class CreditCycleAnalyzer(EconomicsBase):+ """Credit cycle analysis and financial stability assessment"""++ def analyze_credit_cycle(self, credit_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze current credit cycle phase and characteristics"""++ # Extract credit indicators+ credit_growth = self.to_decimal(credit_data.get('credit_growth_rate', 0))+ loan_standards = credit_data.get('lending_standards', 'neutral') # tight, neutral, loose+ credit_spreads = self.to_decimal(credit_data.get('credit_spreads_bps', 0))+ default_rates = self.to_decimal(credit_data.get('default_rate', 0))+ leverage_ratio = self.to_decimal(credit_data.get('leverage_ratio', 0))+ asset_prices = self.to_decimal(credit_data.get('asset_price_growth', 0))++ # Determine credit cycle phase+ cycle_phase = self._determine_credit_phase(+ credit_growth, loan_standards, credit_spreads, default_rates+ )++ return {+ 'credit_cycle_phase': cycle_phase,+ 'phase_characteristics': self._get_credit_phase_characteristics(cycle_phase),+ 'risk_assessment': self._assess_credit_risks(+ credit_growth, leverage_ratio, default_rates, asset_prices+ ),+ 'financial_stability_indicators': self._analyze_financial_stability(credit_data),+ 'investment_implications': self._credit_cycle_investment_implications(cycle_phase),+ 'policy_implications': self._credit_cycle_policy_implications(cycle_phase, credit_data)+ }++ def _determine_credit_phase(self, credit_growth: Decimal, standards: str,+ spreads: Decimal, defaults: Decimal) -> str:+ """Determine current credit cycle phase"""++ # Credit expansion phase+ if (credit_growth > self.to_decimal(5) and+ standards == 'loose' and+ spreads < self.to_decimal(200)):+ return 'expansion'++ # Credit peak/bubble phase+ elif (credit_growth > self.to_decimal(8) and+ spreads < self.to_decimal(150) and+ defaults < self.to_decimal(2)):+ return 'peak'++ # Credit contraction phase+ elif (credit_growth < self.to_decimal(0) and+ standards == 'tight' and+ spreads > self.to_decimal(300)):+ return 'contraction'++ # Credit trough phase+ elif (credit_growth < self.to_decimal(2) and+ defaults > self.to_decimal(5) and+ spreads > self.to_decimal(400)):+ return 'trough'++ else:+ return 'transition'++ def _get_credit_phase_characteristics(self, phase: str) -> Dict[str, Any]:+ """Get characteristics of each credit cycle phase"""++ characteristics = {+ 'expansion': {+ 'credit_growth': 'Accelerating',+ 'lending_standards': 'Loosening',+ 'credit_spreads': 'Tightening',+ 'default_rates': 'Low and declining',+ 'asset_prices': 'Rising',+ 'risk_appetite': 'Increasing',+ 'typical_duration': '3-7 years'+ },+ 'peak': {+ 'credit_growth': 'Very high but potentially slowing',+ 'lending_standards': 'Very loose',+ 'credit_spreads': 'Very tight',+ 'default_rates': 'Near cyclical lows',+ 'asset_prices': 'Near peaks, potential bubbles',+ 'risk_appetite': 'Excessive',+ 'typical_duration': '6-18 months'+ },+ 'contraction': {+ 'credit_growth': 'Negative',+ 'lending_standards': 'Tightening rapidly',+ 'credit_spreads': 'Widening',+ 'default_rates': 'Rising sharply',+ 'asset_prices': 'Declining',+ 'risk_appetite': 'Risk aversion',+ 'typical_duration': '1-3 years'+ },+ 'trough': {+ 'credit_growth': 'Negative but stabilizing',+ 'lending_standards': 'Very tight',+ 'credit_spreads': 'Wide but stabilizing',+ 'default_rates': 'High but peaking',+ 'asset_prices': 'Depressed but stabilizing',+ 'risk_appetite': 'Extremely low',+ 'typical_duration': '6-18 months'+ }+ }++ return characteristics.get(phase, {})++ def _assess_credit_risks(self, credit_growth: Decimal, leverage: Decimal,+ defaults: Decimal, asset_prices: Decimal) -> Dict[str, Any]:+ """Assess systemic credit risks"""++ risk_score = self.to_decimal(0)+ risk_factors = []++ # Credit growth risk+ if credit_growth > self.to_decimal(10):+ risk_score += self.to_decimal(25)+ risk_factors.append('Excessive credit growth')++ # Leverage risk+ if leverage > self.to_decimal(8):+ risk_score += self.to_decimal(25)+ risk_factors.append('High leverage ratios')++ # Default rate risk+ if defaults > self.to_decimal(4):+ risk_score += self.to_decimal(20)+ risk_factors.append('Rising default rates')++ # Asset price risk+ if asset_prices > self.to_decimal(15):+ risk_score += self.to_decimal(20)+ risk_factors.append('Asset price bubbles')++ # Determine risk level+ if risk_score > self.to_decimal(60):+ risk_level = 'High'+ elif risk_score > self.to_decimal(30):+ risk_level = 'Moderate'+ else:+ risk_level = 'Low'++ return {+ 'overall_risk_score': risk_score,+ 'risk_level': risk_level,+ 'key_risk_factors': risk_factors,+ 'systemic_risk_probability': self._calculate_systemic_risk_probability(risk_score)+ }++ def _calculate_systemic_risk_probability(self, risk_score: Decimal) -> str:+ """Calculate probability of systemic financial crisis"""++ if risk_score > self.to_decimal(70):+ return 'High (>30% in next 2 years)'+ elif risk_score > self.to_decimal(50):+ return 'Moderate (10-30% in next 2 years)'+ elif risk_score > self.to_decimal(30):+ return 'Low (5-10% in next 2 years)'+ else:+ return 'Very Low (<5% in next 2 years)'++ def _analyze_financial_stability(self, credit_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze financial stability indicators"""++ return {+ 'banking_sector_health': {+ 'capital_adequacy': credit_data.get('bank_capital_ratio', 'N/A'),+ 'loan_loss_provisions': credit_data.get('loan_loss_provisions', 'N/A'),+ 'profitability': credit_data.get('bank_roe', 'N/A'),+ 'asset_quality': credit_data.get('npl_ratio', 'N/A')+ },+ 'household_sector': {+ 'debt_to_income': credit_data.get('household_debt_ratio', 'N/A'),+ 'mortgage_defaults': credit_data.get('mortgage_default_rate', 'N/A'),+ 'savings_rate': credit_data.get('household_savings_rate', 'N/A')+ },+ 'corporate_sector': {+ 'corporate_debt_ratio': credit_data.get('corporate_debt_gdp', 'N/A'),+ 'interest_coverage': credit_data.get('interest_coverage_ratio', 'N/A'),+ 'bankruptcy_rate': credit_data.get('corporate_bankruptcy_rate', 'N/A')+ },+ 'government_sector': {+ 'debt_to_gdp': credit_data.get('government_debt_gdp', 'N/A'),+ 'deficit_ratio': credit_data.get('budget_deficit_gdp', 'N/A')+ }+ }++ def _credit_cycle_investment_implications(self, phase: str) -> Dict[str, Any]:+ """Investment implications for each credit cycle phase"""++ implications = {+ 'expansion': {+ 'credit_sensitive_sectors': 'Favor banks, real estate, consumer finance',+ 'fixed_income': 'Corporate bonds outperform, credit spreads tighten',+ 'equity_strategy': 'Growth and cyclical stocks perform well',+ 'risk_management': 'Monitor leverage, prepare for cycle turn'+ },+ 'peak': {+ 'credit_sensitive_sectors': 'Begin reducing exposure to credit cyclicals',+ 'fixed_income': 'Lock in credit spreads, extend duration',+ 'equity_strategy': 'Rotate to defensive sectors',+ 'risk_management': 'Reduce overall risk exposure'+ },+ 'contraction': {+ 'credit_sensitive_sectors': 'Avoid banks, real estate, high-yield bonds',+ 'fixed_income': 'Government bonds, high-grade corporates',+ 'equity_strategy': 'Defensive sectors, dividend stocks',+ 'risk_management': 'Capital preservation focus'+ },+ 'trough': {+ 'credit_sensitive_sectors': 'Prepare for opportunistic investments',+ 'fixed_income': 'Distressed debt opportunities',+ 'equity_strategy': 'Value opportunities in beaten-down sectors',+ 'risk_management': 'Begin rebuilding risk exposure'+ }+ }++ return implications.get(phase, {})++ def _credit_cycle_policy_implications(self, phase: str, credit_data: Dict[str, Any]) -> Dict[str, Any]:+ """Policy implications for each credit cycle phase"""++ base_implications = {+ 'expansion': {+ 'monetary_policy': 'Consider gradual tightening to prevent bubbles',+ 'macroprudential': 'Implement countercyclical capital buffers',+ 'regulatory': 'Monitor systemic risk buildup'+ },+ 'peak': {+ 'monetary_policy': 'Careful balancing to prevent hard landing',+ 'macroprudential': 'Activate countercyclical buffers',+ 'regulatory': 'Stress test financial institutions'+ },+ 'contraction': {+ 'monetary_policy': 'Aggressive easing to support credit flow',+ 'macroprudential': 'Release countercyclical buffers',+ 'regulatory': 'Temporary forbearance measures'+ },+ 'trough': {+ 'monetary_policy': 'Maintain accommodative stance',+ 'macroprudential': 'Gradual rebuilding of buffers',+ 'regulatory': 'Support credit intermediation'+ }+ }++ return base_implications.get(phase, {})++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate credit cycle analysis"""+ return self.analyze_credit_cycle(kwargs['credit_data'])+++class MarketStructureAnalyzer(EconomicsBase):+ """Market structure analysis and competitive dynamics"""++ def identify_market_structure(self, market_data: Dict[str, Any]) -> Dict[str, Any]:+ """Identify market structure type and characteristics"""++ # Extract market characteristics+ num_firms = int(market_data.get('number_of_firms', 0))+ market_concentration = self.to_decimal(market_data.get('herfindahl_index', 0))+ product_differentiation = market_data.get('product_differentiation', 'low')+ barriers_to_entry = market_data.get('barriers_to_entry', 'low')+ pricing_power = market_data.get('pricing_power', 'low')++ # Determine market structure+ structure_type = self._classify_market_structure(+ num_firms, market_concentration, product_differentiation, barriers_to_entry+ )++ return {+ 'market_structure_type': structure_type,+ 'structure_characteristics': self._get_structure_characteristics(structure_type),+ 'concentration_analysis': self._analyze_concentration(market_concentration, num_firms),+ 'competitive_dynamics': self._analyze_competitive_dynamics(structure_type, market_data),+ 'pricing_analysis': self._analyze_pricing_behavior(structure_type, market_data),+ 'efficiency_implications': self._analyze_efficiency_implications(structure_type),+ 'regulatory_considerations': self._get_regulatory_considerations(structure_type)+ }++ def _classify_market_structure(self, num_firms: int, concentration: Decimal,+ differentiation: str, barriers: str) -> str:+ """Classify market structure based on key characteristics"""++ # Perfect competition+ if (num_firms > 100 and+ concentration < self.to_decimal(0.01) and+ differentiation == 'none' and+ barriers == 'low'):+ return 'perfect_competition'++ # Monopoly+ elif num_firms == 1 or concentration > self.to_decimal(0.9):+ return 'monopoly'++ # Oligopoly+ elif (num_firms <= 10 and+ concentration > self.to_decimal(0.6) and+ barriers in ['high', 'moderate']):+ return 'oligopoly'++ # Monopolistic competition+ else:+ return 'monopolistic_competition'++ def _get_structure_characteristics(self, structure_type: str) -> Dict[str, Any]:+ """Get detailed characteristics of each market structure"""++ characteristics = {+ 'perfect_competition': {+ 'number_of_firms': 'Many (hundreds or thousands)',+ 'product_differentiation': 'None (homogeneous products)',+ 'barriers_to_entry': 'None',+ 'pricing_power': 'None (price takers)',+ 'long_run_profits': 'Zero economic profits',+ 'efficiency': 'Allocatively and productively efficient',+ 'examples': 'Agricultural markets, commodity markets'+ },+ 'monopolistic_competition': {+ 'number_of_firms': 'Many (dozens to hundreds)',+ 'product_differentiation': 'Some (differentiated products)',+ 'barriers_to_entry': 'Low',+ 'pricing_power': 'Limited (some control over price)',+ 'long_run_profits': 'Zero economic profits',+ 'efficiency': 'Not fully efficient due to excess capacity',+ 'examples': 'Restaurants, retail clothing, personal services'+ },+ 'oligopoly': {+ 'number_of_firms': 'Few (typically 3-10)',+ 'product_differentiation': 'May be homogeneous or differentiated',+ 'barriers_to_entry': 'High',+ 'pricing_power': 'Significant (price makers)',+ 'long_run_profits': 'Positive economic profits possible',+ 'efficiency': 'Generally inefficient, potential for collusion',+ 'examples': 'Airlines, telecommunications, automobiles'+ },+ 'monopoly': {+ 'number_of_firms': 'One',+ 'product_differentiation': 'Unique product (no close substitutes)',+ 'barriers_to_entry': 'Very high or absolute',+ 'pricing_power': 'Maximum (price maker)',+ 'long_run_profits': 'Positive economic profits',+ 'efficiency': 'Allocatively inefficient, may be productively efficient',+ 'examples': 'Public utilities, patented drugs, natural monopolies'+ }+ }++ return characteristics.get(structure_type, {})++ def _analyze_concentration(self, hhi: Decimal, num_firms: int) -> Dict[str, Any]:+ """Analyze market concentration using various measures"""++ # Herfindahl-Hirschman Index interpretation+ if hhi > self.to_decimal(0.25):+ concentration_level = 'Highly Concentrated'+ antitrust_concern = 'High'+ elif hhi > self.to_decimal(0.15):+ concentration_level = 'Moderately Concentrated'+ antitrust_concern = 'Moderate'+ else:+ concentration_level = 'Unconcentrated'+ antitrust_concern = 'Low'++ # Calculate approximate market shares (simplified)+ if num_firms > 0:+ avg_market_share = self.to_decimal(1) / self.to_decimal(num_firms)+ else:+ avg_market_share = self.to_decimal(0)++ return {+ 'herfindahl_index': hhi,+ 'concentration_level': concentration_level,+ 'antitrust_concern': antitrust_concern,+ 'number_of_firms': num_firms,+ 'average_market_share': avg_market_share * self.to_decimal(100),+ 'concentration_interpretation': self._interpret_hhi(hhi)+ }++ def _interpret_hhi(self, hhi: Decimal) -> str:+ """Interpret HHI values"""+ if hhi > self.to_decimal(0.25):+ return "Market dominated by few large firms, potential monopoly power"+ elif hhi > self.to_decimal(0.15):+ return "Market moderately concentrated, some pricing power exists"+ elif hhi > self.to_decimal(0.1):+ return "Market somewhat concentrated, limited pricing power"+ else:+ return "Market unconcentrated, competitive pricing likely"++ def _analyze_competitive_dynamics(self, structure_type: str, market_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze competitive dynamics for each market structure"""++ dynamics = {+ 'perfect_competition': {+ 'competition_intensity': 'Maximum',+ 'strategic_behavior': 'None (price takers)',+ 'product_strategy': 'Focus on cost efficiency',+ 'market_response': 'Immediate price adjustments',+ 'long_term_strategy': 'Operational excellence'+ },+ 'monopolistic_competition': {+ 'competition_intensity': 'High but differentiated',+ 'strategic_behavior': 'Product differentiation focus',+ 'product_strategy': 'Brand building, innovation',+ 'market_response': 'Gradual price and product adjustments',+ 'long_term_strategy': 'Sustainable differentiation'+ },+ 'oligopoly': {+ 'competition_intensity': 'Strategic interdependence',+ 'strategic_behavior': 'Game theory applies, potential collusion',+ 'product_strategy': 'Innovation and differentiation',+ 'market_response': 'Strategic reactions to competitors',+ 'long_term_strategy': 'Market share protection'+ },+ 'monopoly': {+ 'competition_intensity': 'None or minimal',+ 'strategic_behavior': 'Price and output optimization',+ 'product_strategy': 'Innovation optional',+ 'market_response': 'Independent pricing decisions',+ 'long_term_strategy': 'Barrier maintenance'+ }+ }++ return dynamics.get(structure_type, {})++ def calculate_breakeven_shutdown_points(self, cost_data: Dict[str, Any],+ market_structure: str) -> Dict[str, Any]:+ """Calculate breakeven and shutdown points for different market structures"""++ # Extract cost data+ fixed_costs = self.to_decimal(cost_data.get('fixed_costs', 0))+ variable_cost_per_unit = self.to_decimal(cost_data.get('variable_cost_per_unit', 0))+ market_price = self.to_decimal(cost_data.get('market_price', 0))+ capacity = self.to_decimal(cost_data.get('capacity', 0))++ # Calculate key cost metrics+ total_costs = lambda q: fixed_costs + variable_cost_per_unit * q+ average_total_cost = lambda q: total_costs(q) / q if q > 0 else self.to_decimal(0)+ average_variable_cost = variable_cost_per_unit+ marginal_cost = variable_cost_per_unit # Simplified assumption++ # Breakeven point (where economic profit = 0)+ if market_price > variable_cost_per_unit:+ breakeven_quantity = fixed_costs / (market_price - variable_cost_per_unit)+ else:+ breakeven_quantity = None # Cannot break even++ # Shutdown point (where price < AVC)+ shutdown_price = average_variable_cost++ # Calculate optimal production for different market structures+ optimal_output = self._calculate_optimal_output(+ market_structure, market_price, marginal_cost, capacity+ )++ return {+ 'cost_structure': {+ 'fixed_costs': fixed_costs,+ 'variable_cost_per_unit': variable_cost_per_unit,+ 'average_variable_cost': average_variable_cost,+ 'marginal_cost': marginal_cost+ },+ 'breakeven_analysis': {+ 'breakeven_quantity': breakeven_quantity,+ 'breakeven_revenue': breakeven_quantity * market_price if breakeven_quantity else None,+ 'contribution_margin': market_price - variable_cost_per_unit,+ 'contribution_margin_ratio': ((market_price - variable_cost_per_unit) / market_price * self.to_decimal(+ 100)) if market_price > 0 else self.to_decimal(0)+ },+ 'shutdown_analysis': {+ 'shutdown_price': shutdown_price,+ 'current_price': market_price,+ 'should_shutdown': market_price < shutdown_price,+ 'shutdown_loss': fixed_costs if market_price < shutdown_price else self.to_decimal(0)+ },+ 'optimal_production': {+ 'optimal_quantity': optimal_output,+ 'total_revenue': optimal_output * market_price,+ 'total_costs': total_costs(optimal_output),+ 'economic_profit': optimal_output * market_price - total_costs(optimal_output)+ },+ 'scale_economies': self._analyze_economies_of_scale(cost_data, optimal_output)+ }++ def _calculate_optimal_output(self, structure_type: str, price: Decimal,+ marginal_cost: Decimal, capacity: Decimal) -> Decimal:+ """Calculate optimal output for different market structures"""++ if structure_type == 'perfect_competition':+ # P = MC+ if price >= marginal_cost:+ return capacity # Produce at capacity if profitable+ else:+ return self.to_decimal(0) # Shutdown if price < MC++ elif structure_type == 'monopolistic_competition':+ # MR = MC, but with some pricing power+ # Simplified: produce where P > MC but not at full capacity+ if price > marginal_cost:+ return capacity * self.to_decimal(0.8) # 80% of capacity+ else:+ return self.to_decimal(0)++ elif structure_type in ['oligopoly', 'monopoly']:+ # More complex optimization considering market power+ # Simplified: produce where MR = MC+ if price > marginal_cost * self.to_decimal(1.2): # Account for markup+ return capacity * self.to_decimal(0.7) # 70% of capacity+ else:+ return capacity * self.to_decimal(0.5) # 50% of capacity++ else:+ return capacity * self.to_decimal(0.75) # Default assumption++ def _analyze_economies_of_scale(self, cost_data: Dict[str, Any],+ current_output: Decimal) -> Dict[str, Any]:+ """Analyze economies and diseconomies of scale"""++ # Extract scale-related data+ min_efficient_scale = self.to_decimal(cost_data.get('min_efficient_scale', 0))+ capacity = self.to_decimal(cost_data.get('capacity', 0))++ # Determine scale position+ if current_output < min_efficient_scale:+ scale_position = 'Below minimum efficient scale'+ scale_effect = 'Economies of scale available'+ recommendation = 'Increase production to reduce average costs'+ elif current_output <= capacity * self.to_decimal(0.9):+ scale_position = 'At or near optimal scale'+ scale_effect = 'Constant returns to scale'+ recommendation = 'Current scale is efficient'+ else:+ scale_position = 'Above optimal scale'+ scale_effect = 'Potential diseconomies of scale'+ recommendation = 'Consider capacity expansion or efficiency improvements'++ return {+ 'current_output': current_output,+ 'minimum_efficient_scale': min_efficient_scale,+ 'capacity_utilization': (+ current_output / capacity * self.to_decimal(100)) if capacity > 0 else self.to_decimal(0),+ 'scale_position': scale_position,+ 'scale_effect': scale_effect,+ 'recommendation': recommendation+ }++ def _analyze_pricing_behavior(self, structure_type: str, market_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze pricing behavior and strategies for each market structure"""++ pricing_behavior = {+ 'perfect_competition': {+ 'pricing_strategy': 'Price taking (no control)',+ 'price_setting': 'Market determined',+ 'demand_curve': 'Perfectly elastic',+ 'profit_maximization': 'P = MC',+ 'price_discrimination': 'Not possible'+ },+ 'monopolistic_competition': {+ 'pricing_strategy': 'Limited pricing power',+ 'price_setting': 'Some control over price',+ 'demand_curve': 'Downward sloping but elastic',+ 'profit_maximization': 'MR = MC',+ 'price_discrimination': 'Limited opportunities'+ },+ 'oligopoly': {+ 'pricing_strategy': 'Strategic pricing',+ 'price_setting': 'Mutual interdependence',+ 'demand_curve': 'Kinked demand curve possible',+ 'profit_maximization': 'Game theory considerations',+ 'price_discrimination': 'Possible with market segmentation'+ },+ 'monopoly': {+ 'pricing_strategy': 'Price maker',+ 'price_setting': 'Full control subject to demand',+ 'demand_curve': 'Downward sloping',+ 'profit_maximization': 'MR = MC',+ 'price_discrimination': 'Multiple types possible'+ }+ }++ return pricing_behavior.get(structure_type, {})++ def _analyze_efficiency_implications(self, structure_type: str) -> Dict[str, Any]:+ """Analyze efficiency implications of each market structure"""++ efficiency = {+ 'perfect_competition': {+ 'allocative_efficiency': 'Yes (P = MC)',+ 'productive_efficiency': 'Yes (minimum ATC)',+ 'dynamic_efficiency': 'Limited (low profits for R&D)',+ 'consumer_surplus': 'Maximized',+ 'deadweight_loss': 'None'+ },+ 'monopolistic_competition': {+ 'allocative_efficiency': 'No (P > MC)',+ 'productive_efficiency': 'No (excess capacity)',+ 'dynamic_efficiency': 'Moderate (innovation incentives)',+ 'consumer_surplus': 'Reduced due to higher prices',+ 'deadweight_loss': 'Small'+ },+ 'oligopoly': {+ 'allocative_efficiency': 'No (P > MC)',+ 'productive_efficiency': 'Uncertain (may achieve scale economies)',+ 'dynamic_efficiency': 'High (R&D competition)',+ 'consumer_surplus': 'Significantly reduced',+ 'deadweight_loss': 'Moderate to large'+ },+ 'monopoly': {+ 'allocative_efficiency': 'No (P > MC)',+ 'productive_efficiency': 'Uncertain (may achieve scale economies)',+ 'dynamic_efficiency': 'Low (limited competition pressure)',+ 'consumer_surplus': 'Minimized',+ 'deadweight_loss': 'Large'+ }+ }++ return efficiency.get(structure_type, {})++ def _get_regulatory_considerations(self, structure_type: str) -> Dict[str, Any]:+ """Get regulatory considerations for each market structure"""++ regulations = {+ 'perfect_competition': {+ 'antitrust_concern': 'None',+ 'regulation_needed': 'Minimal',+ 'focus': 'Maintain competitive conditions',+ 'interventions': 'Prevent artificial barriers to entry'+ },+ 'monopolistic_competition': {+ 'antitrust_concern': 'Low',+ 'regulation_needed': 'Light touch',+ 'focus': 'Consumer protection, fair advertising',+ 'interventions': 'Truth in advertising, quality standards'+ },+ 'oligopoly': {+ 'antitrust_concern': 'High',+ 'regulation_needed': 'Active monitoring',+ 'focus': 'Prevent collusion, monitor mergers',+ 'interventions': 'Merger review, price fixing prevention'+ },+ 'monopoly': {+ 'antitrust_concern': 'Very high',+ 'regulation_needed': 'Heavy regulation or breakup',+ 'focus': 'Price regulation, service quality',+ 'interventions': 'Rate regulation, structural remedies'+ }+ }++ return regulations.get(structure_type, {})++ def calculate(self, analysis_type: str = 'structure_identification', **kwargs) -> Dict[str, Any]:+ """Main market structure calculation dispatcher"""++ if analysis_type == 'structure_identification':+ return self.identify_market_structure(kwargs['market_data'])+ elif analysis_type == 'breakeven_shutdown':+ return self.calculate_breakeven_shutdown_points(+ kwargs['cost_data'], kwargs['market_structure']+ )+ else:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/policy_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/policy_analysis.pynew file mode 100644index 000000000..c1a9faa59--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/policy_analysis.py@@ -0,0 +1,586 @@++Economic Policy Analysis Module+=============================++Economic policy impact assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++from decimal import Decimal+from typing import Dict, List, Any+from .core import EconomicsBase, ValidationError+++class FiscalPolicyAnalyzer(EconomicsBase):+ """Fiscal policy analysis and impact assessment"""++ def compare_fiscal_monetary(self) -> Dict[str, Any]:+ """Compare fiscal and monetary policy characteristics"""+ return {+ 'fiscal_policy': {+ 'authority': 'Government (legislative/executive)',+ 'tools': ['Government spending', 'Taxation', 'Transfer payments'],+ 'targets': ['Economic growth', 'Employment', 'Income distribution'],+ 'transmission': 'Direct impact on aggregate demand',+ 'lag_time': 'Long (6-18 months)',+ 'political_influence': 'High',+ 'flexibility': 'Low (requires legislative approval)'+ },+ 'monetary_policy': {+ 'authority': 'Central bank',+ 'tools': ['Interest rates', 'Money supply', 'Reserve requirements'],+ 'targets': ['Price stability', 'Economic growth', 'Financial stability'],+ 'transmission': 'Indirect through financial markets',+ 'lag_time': 'Medium (3-12 months)',+ 'political_influence': 'Low (independent)',+ 'flexibility': 'High (quick implementation)'+ },+ 'interaction_effects': {+ 'complementary': 'Both expansionary during recession',+ 'conflicting': 'Fiscal expansion with monetary tightening',+ 'coordination_importance': 'Critical for policy effectiveness'+ }+ }++ def analyze_fiscal_tools(self, policy_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze fiscal policy tools and their effects"""+ tools_analysis = {+ 'government_spending': {+ 'multiplier_effect': self._calculate_spending_multiplier(policy_data),+ 'advantages': ['Direct job creation', 'Infrastructure investment', 'Quick stimulus'],+ 'disadvantages': ['Crowding out private investment', 'Debt accumulation', 'Political interference'],+ 'effectiveness': 'High during recessions, moderate during expansions'+ },+ 'taxation': {+ 'multiplier_effect': self._calculate_tax_multiplier(policy_data),+ 'advantages': ['Broad-based impact', 'Revenue generation', 'Incentive alignment'],+ 'disadvantages': ['Lagged response', 'Political constraints', 'Distortionary effects'],+ 'effectiveness': 'Moderate, depends on tax type and economic conditions'+ },+ 'transfer_payments': {+ 'multiplier_effect': self._calculate_transfer_multiplier(policy_data),+ 'advantages': ['Targeted support', 'Automatic stabilizers', 'Social safety net'],+ 'disadvantages': ['Potential dependency', 'Fiscal burden', 'Limited growth impact'],+ 'effectiveness': 'High for consumption support, moderate for growth'+ }+ }++ return {+ 'tools_analysis': tools_analysis,+ 'implementation_challenges': self._assess_implementation_challenges(),+ 'policy_recommendation': self._recommend_fiscal_mix(policy_data)+ }++ def assess_debt_sustainability(self, debt_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess whether national debt relative to GDP matters"""+ debt_gdp = self.to_decimal(debt_data.get('debt_to_gdp_ratio', 0))+ gdp_growth = self.to_decimal(debt_data.get('gdp_growth_rate', 0))+ interest_rate = self.to_decimal(debt_data.get('avg_interest_rate', 0))+ primary_balance = self.to_decimal(debt_data.get('primary_balance_gdp', 0))++ # Debt sustainability condition: r < g + primary_balance_ratio+ sustainability_gap = interest_rate - gdp_growth - primary_balance++ # Risk thresholds+ if debt_gdp > self.to_decimal(100):+ risk_level = 'Very High'+ elif debt_gdp > self.to_decimal(60):+ risk_level = 'High'+ elif debt_gdp > self.to_decimal(40):+ risk_level = 'Moderate'+ else:+ risk_level = 'Low'++ return {+ 'debt_to_gdp': debt_gdp,+ 'sustainability_gap': sustainability_gap,+ 'sustainable': sustainability_gap < self.to_decimal(0),+ 'risk_level': risk_level,+ 'debt_dynamics': {+ 'interest_burden': interest_rate * debt_gdp / self.to_decimal(100),+ 'growth_benefit': gdp_growth * debt_gdp / self.to_decimal(100),+ 'primary_contribution': primary_balance+ },+ 'implications': self._get_debt_implications(debt_gdp, sustainability_gap)+ }++ def identify_policy_stance(self, fiscal_indicators: Dict[str, Any]) -> Dict[str, Any]:+ """Identify if fiscal policy is expansionary or contractionary"""+ spending_change = self.to_decimal(fiscal_indicators.get('spending_change_percent', 0))+ tax_change = self.to_decimal(fiscal_indicators.get('tax_change_percent', 0))+ deficit_change = self.to_decimal(fiscal_indicators.get('deficit_change_gdp', 0))++ # Calculate fiscal impulse+ fiscal_impulse = spending_change - tax_change++ if fiscal_impulse > self.to_decimal(1):+ stance = 'Expansionary'+ description = 'Government increasing spending more than taxes'+ elif fiscal_impulse < self.to_decimal(-1):+ stance = 'Contractionary'+ description = 'Government reducing spending or increasing taxes significantly'+ else:+ stance = 'Neutral'+ description = 'Minimal net fiscal impact'++ return {+ 'fiscal_stance': stance,+ 'fiscal_impulse': fiscal_impulse,+ 'description': description,+ 'stance_indicators': {+ 'spending_change': spending_change,+ 'tax_change': tax_change,+ 'deficit_change': deficit_change+ },+ 'economic_impact': self._assess_stance_impact(stance, fiscal_impulse)+ }++ def _calculate_spending_multiplier(self, data: Dict[str, Any]) -> Decimal:+ """Calculate government spending multiplier"""+ mpc = self.to_decimal(data.get('marginal_propensity_consume', 0.8))+ return self.to_decimal(1) / (self.to_decimal(1) - mpc)++ def _calculate_tax_multiplier(self, data: Dict[str, Any]) -> Decimal:+ """Calculate tax multiplier"""+ mpc = self.to_decimal(data.get('marginal_propensity_consume', 0.8))+ return -mpc / (self.to_decimal(1) - mpc)++ def _calculate_transfer_multiplier(self, data: Dict[str, Any]) -> Decimal:+ """Calculate transfer payment multiplier"""+ mpc = self.to_decimal(data.get('marginal_propensity_consume', 0.8))+ return mpc / (self.to_decimal(1) - mpc)++ def _assess_implementation_challenges(self) -> List[str]:+ """Assess fiscal policy implementation difficulties"""+ return [+ 'Recognition lag: Time to identify economic problems',+ 'Legislative lag: Time for political approval',+ 'Implementation lag: Time to execute policy',+ 'Political constraints: Electoral and partisan considerations',+ 'Crowding out: Government borrowing affects private investment',+ 'Ricardian equivalence: Tax cuts offset by expected future taxes'+ ]++ def _recommend_fiscal_mix(self, data: Dict[str, Any]) -> Dict[str, str]:+ """Recommend optimal fiscal policy mix"""+ unemployment = self.to_decimal(data.get('unemployment_rate', 0))+ inflation = self.to_decimal(data.get('inflation_rate', 0))++ if unemployment > self.to_decimal(7):+ return {'recommendation': 'Expansionary', 'focus': 'Job creation and demand stimulus'}+ elif inflation > self.to_decimal(4):+ return {'recommendation': 'Contractionary', 'focus': 'Reduce demand pressures'}+ else:+ return {'recommendation': 'Neutral', 'focus': 'Maintain fiscal balance'}++ def _get_debt_implications(self, debt_gdp: Decimal, gap: Decimal) -> Dict[str, str]:+ """Get implications of debt sustainability analysis"""+ if gap > self.to_decimal(2):+ return {+ 'fiscal_space': 'Limited',+ 'interest_burden': 'High and rising',+ 'policy_flexibility': 'Constrained',+ 'investor_confidence': 'At risk'+ }+ else:+ return {+ 'fiscal_space': 'Adequate',+ 'interest_burden': 'Manageable',+ 'policy_flexibility': 'Available',+ 'investor_confidence': 'Stable'+ }++ def _assess_stance_impact(self, stance: str, impulse: Decimal) -> Dict[str, str]:+ """Assess economic impact of fiscal stance"""+ impacts = {+ 'Expansionary': {+ 'gdp_impact': 'Positive stimulus to growth',+ 'employment_impact': 'Job creation likely',+ 'inflation_risk': 'Potential upward pressure',+ 'debt_impact': 'Increased deficit spending'+ },+ 'Contractionary': {+ 'gdp_impact': 'Negative drag on growth',+ 'employment_impact': 'Potential job losses',+ 'inflation_risk': 'Reduced price pressures',+ 'debt_impact': 'Deficit reduction'+ },+ 'Neutral': {+ 'gdp_impact': 'Minimal direct impact',+ 'employment_impact': 'Status quo maintained',+ 'inflation_risk': 'No significant pressure',+ 'debt_impact': 'Stable debt dynamics'+ }+ }+ return impacts.get(stance, {})++ def calculate(self, analysis_type: str = 'tools_analysis', **kwargs) -> Dict[str, Any]:+ """Main fiscal policy calculation dispatcher"""+ analyses = {+ 'compare_policies': self.compare_fiscal_monetary,+ 'tools_analysis': lambda: self.analyze_fiscal_tools(kwargs.get('policy_data', {})),+ 'debt_sustainability': lambda: self.assess_debt_sustainability(kwargs.get('debt_data', {})),+ 'policy_stance': lambda: self.identify_policy_stance(kwargs.get('fiscal_indicators', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class MonetaryPolicyAnalyzer(EconomicsBase):+ """Monetary policy analysis and transmission mechanism"""++ def analyze_central_bank_roles(self) -> Dict[str, Any]:+ """Describe central bank roles and objectives"""+ return {+ 'primary_objectives': {+ 'price_stability': 'Maintain low and stable inflation',+ 'economic_growth': 'Support sustainable economic expansion',+ 'financial_stability': 'Ensure stable financial system',+ 'employment': 'Some central banks have explicit employment mandate'+ },+ 'key_functions': {+ 'monetary_policy': 'Set interest rates and control money supply',+ 'banking_supervision': 'Regulate and supervise financial institutions',+ 'lender_of_last_resort': 'Provide emergency liquidity to banks',+ 'currency_issuance': 'Issue and manage national currency',+ 'government_banker': 'Provide banking services to government'+ },+ 'independence_importance': {+ 'political_independence': 'Avoid short-term political pressures',+ 'operational_independence': 'Freedom to choose policy tools',+ 'accountability': 'Report to legislature on performance'+ }+ }++ def analyze_monetary_tools(self, policy_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze monetary policy tools and transmission mechanism"""+ return {+ 'conventional_tools': {+ 'policy_rate': {+ 'description': 'Central bank key interest rate',+ 'current_rate': policy_data.get('policy_rate', 'N/A'),+ 'transmission': 'Affects all market rates',+ 'effectiveness': 'High when rates above zero lower bound'+ },+ 'reserve_requirements': {+ 'description': 'Banks required reserve ratio',+ 'current_ratio': policy_data.get('reserve_ratio', 'N/A'),+ 'transmission': 'Affects bank lending capacity',+ 'effectiveness': 'Powerful but rarely used'+ },+ 'open_market_operations': {+ 'description': 'Buy/sell government securities',+ 'current_balance_sheet': policy_data.get('central_bank_balance_sheet', 'N/A'),+ 'transmission': 'Direct impact on money supply',+ 'effectiveness': 'Most frequently used tool'+ }+ },+ 'unconventional_tools': {+ 'quantitative_easing': 'Large-scale asset purchases',+ 'forward_guidance': 'Communication about future policy',+ 'negative_rates': 'Below-zero policy rates',+ 'yield_curve_control': 'Target specific maturity yields'+ },+ 'transmission_mechanism': self._analyze_transmission_mechanism(policy_data)+ }++ def analyze_targeting_strategies(self, strategy_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze different monetary policy targeting strategies"""+ strategies = {+ 'inflation_targeting': {+ 'target': strategy_data.get('inflation_target', '2%'),+ 'advantages': ['Clear communication', 'Credible commitment', 'Flexible response'],+ 'disadvantages': ['Ignores other variables', 'May miss asset bubbles', 'Measurement issues'],+ 'effectiveness': 'High for anchoring expectations'+ },+ 'interest_rate_targeting': {+ 'target': strategy_data.get('interest_rate_target', 'Variable'),+ 'advantages': ['Direct control', 'Clear signal', 'Quick transmission'],+ 'disadvantages': ['May ignore inflation', 'Procyclical risks', 'Zero lower bound'],+ 'effectiveness': 'High for short-term stabilization'+ },+ 'exchange_rate_targeting': {+ 'target': strategy_data.get('exchange_rate_target', 'N/A'),+ 'advantages': ['Trade stability', 'Import price stability', 'Simple communication'],+ 'disadvantages': ['Loss of monetary independence', 'Vulnerable to attacks', 'Limited flexibility'],+ 'effectiveness': 'Moderate, depends on economic structure'+ }+ }++ return {+ 'targeting_strategies': strategies,+ 'strategy_comparison': self._compare_targeting_strategies(),+ 'optimal_strategy_recommendation': self._recommend_targeting_strategy(strategy_data)+ }++ def assess_policy_effectiveness(self, effectiveness_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess monetary policy effectiveness and limitations"""+ return {+ 'effectiveness_factors': {+ 'central_bank_credibility': effectiveness_data.get('credibility_index', 'N/A'),+ 'financial_system_development': effectiveness_data.get('financial_development_index', 'N/A'),+ 'economic_structure': effectiveness_data.get('economic_structure', 'N/A'),+ 'inflation_expectations_anchoring': effectiveness_data.get('expectations_anchored', 'N/A')+ },+ 'policy_limitations': {+ 'zero_lower_bound': 'Cannot cut rates below certain level',+ 'liquidity_trap': 'Money demand becomes perfectly elastic',+ 'long_and_variable_lags': 'Policy effects take 6-18 months',+ 'asset_bubbles': 'Difficulty identifying and responding to bubbles',+ 'financial_stability': 'Trade-offs between price and financial stability'+ },+ 'effectiveness_assessment': self._assess_current_effectiveness(effectiveness_data)+ }++ def analyze_policy_interaction(self, interaction_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze interaction between monetary and fiscal policy"""+ fiscal_stance = interaction_data.get('fiscal_stance', 'neutral')+ monetary_stance = interaction_data.get('monetary_stance', 'neutral')++ interaction_matrix = {+ ('expansionary', 'expansionary'): {+ 'coordination': 'Aligned',+ 'economic_impact': 'Strong stimulus',+ 'risks': 'Overheating, inflation',+ 'appropriate_when': 'Deep recession'+ },+ ('expansionary', 'contractionary'): {+ 'coordination': 'Conflicting',+ 'economic_impact': 'Uncertain, depends on relative strength',+ 'risks': 'Policy ineffectiveness',+ 'appropriate_when': 'Fiscal stimulus with inflation concerns'+ },+ ('contractionary', 'expansionary'): {+ 'coordination': 'Conflicting',+ 'economic_impact': 'Uncertain, mixed signals',+ 'risks': 'Policy confusion',+ 'appropriate_when': 'Fiscal consolidation with growth support'+ },+ ('contractionary', 'contractionary'): {+ 'coordination': 'Aligned',+ 'economic_impact': 'Strong contraction',+ 'risks': 'Excessive slowdown',+ 'appropriate_when': 'High inflation, overheating'+ }+ }++ current_interaction = interaction_matrix.get((fiscal_stance, monetary_stance), {+ 'coordination': 'Unknown',+ 'economic_impact': 'Uncertain',+ 'risks': 'Unknown',+ 'appropriate_when': 'Unclear'+ })++ return {+ 'current_policy_mix': {+ 'fiscal_stance': fiscal_stance,+ 'monetary_stance': monetary_stance+ },+ 'interaction_analysis': current_interaction,+ 'coordination_quality': self._assess_coordination_quality(interaction_data),+ 'policy_recommendations': self._recommend_policy_coordination(fiscal_stance, monetary_stance)+ }++ def _analyze_transmission_mechanism(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze monetary policy transmission channels"""+ return {+ 'interest_rate_channel': {+ 'mechanism': 'Policy rate → Market rates → Investment/Consumption',+ 'strength': 'Strong in developed economies',+ 'lag': '6-12 months'+ },+ 'credit_channel': {+ 'mechanism': 'Policy → Bank lending → Economic activity',+ 'strength': 'Important for bank-dependent economies',+ 'lag': '3-9 months'+ },+ 'exchange_rate_channel': {+ 'mechanism': 'Policy rate → Exchange rate → Net exports',+ 'strength': 'Strong in open economies',+ 'lag': '3-6 months'+ },+ 'asset_price_channel': {+ 'mechanism': 'Policy → Asset prices → Wealth → Consumption',+ 'strength': 'Important with developed capital markets',+ 'lag': '6-18 months'+ },+ 'expectations_channel': {+ 'mechanism': 'Policy communication → Expectations → Decisions',+ 'strength': 'Critical for all economies',+ 'lag': 'Immediate to 3 months'+ }+ }++ def _compare_targeting_strategies(self) -> Dict[str, Any]:+ """Compare different targeting strategies"""+ return {+ 'flexibility_ranking': ['Inflation targeting', 'Interest rate targeting', 'Exchange rate targeting'],+ 'credibility_ranking': ['Exchange rate targeting', 'Inflation targeting', 'Interest rate targeting'],+ 'transparency_ranking': ['Inflation targeting', 'Exchange rate targeting', 'Interest rate targeting'],+ 'current_popularity': 'Inflation targeting most widely adopted'+ }++ def _recommend_targeting_strategy(self, data: Dict[str, Any]) -> str:+ """Recommend optimal targeting strategy"""+ openness = data.get('trade_openness', 0.5)+ inflation_volatility = data.get('inflation_volatility', 0.02)++ if openness > 0.7 and inflation_volatility > 0.05:+ return 'Exchange rate targeting for trade-dependent economy'+ elif inflation_volatility > 0.03:+ return 'Inflation targeting for price stability'+ else:+ return 'Flexible inflation targeting with growth consideration'++ def _assess_current_effectiveness(self, data: Dict[str, Any]) -> str:+ """Assess current monetary policy effectiveness"""+ policy_rate = self.to_decimal(data.get('policy_rate', 2))+ inflation_expectations = data.get('expectations_anchored', True)++ if policy_rate < self.to_decimal(0.5) and not inflation_expectations:+ return 'Low effectiveness - at zero lower bound with unanchored expectations'+ elif policy_rate < self.to_decimal(0.5):+ return 'Moderate effectiveness - limited by zero lower bound'+ elif not inflation_expectations:+ return 'Moderate effectiveness - limited by unanchored expectations'+ else:+ return 'High effectiveness - conventional policy space available'++ def _assess_coordination_quality(self, data: Dict[str, Any]) -> str:+ """Assess quality of fiscal-monetary coordination"""+ coordination_score = data.get('coordination_index', 0.5)++ if coordination_score > 0.8:+ return 'Excellent coordination'+ elif coordination_score > 0.6:+ return 'Good coordination'+ elif coordination_score > 0.4:+ return 'Moderate coordination'+ else:+ return 'Poor coordination'++ def _recommend_policy_coordination(self, fiscal: str, monetary: str) -> List[str]:+ """Recommend improvements to policy coordination"""+ if fiscal == monetary:+ return ['Maintain current alignment', 'Monitor for potential overshooting']+ else:+ return [+ 'Improve communication between authorities',+ 'Clarify policy objectives and timing',+ 'Consider joint policy statements'+ ]++ def calculate(self, analysis_type: str = 'tools_analysis', **kwargs) -> Dict[str, Any]:+ """Main monetary policy calculation dispatcher"""+ analyses = {+ 'central_bank_roles': self.analyze_central_bank_roles,+ 'tools_analysis': lambda: self.analyze_monetary_tools(kwargs.get('policy_data', {})),+ 'targeting_strategies': lambda: self.analyze_targeting_strategies(kwargs.get('strategy_data', {})),+ 'effectiveness_assessment': lambda: self.assess_policy_effectiveness(kwargs.get('effectiveness_data', {})),+ 'policy_interaction': lambda: self.analyze_policy_interaction(kwargs.get('interaction_data', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class CentralBankAnalyzer(EconomicsBase):+ """Central bank effectiveness and quality analysis"""++ def assess_central_bank_quality(self, cb_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess qualities of effective central banks"""+ quality_metrics = {+ 'independence': {+ 'score': self.to_decimal(cb_data.get('independence_index', 0.5)),+ 'components': ['Political independence', 'Operational independence', 'Financial independence'],+ 'importance': 'Critical for credibility and long-term focus'+ },+ 'transparency': {+ 'score': self.to_decimal(cb_data.get('transparency_index', 0.5)),+ 'components': ['Clear communication', 'Regular reporting', 'Decision explanations'],+ 'importance': 'Essential for expectation management'+ },+ 'accountability': {+ 'score': self.to_decimal(cb_data.get('accountability_index', 0.5)),+ 'components': ['Legislative oversight', 'Performance reporting', 'Public scrutiny'],+ 'importance': 'Democratic legitimacy and performance monitoring'+ },+ 'technical_competence': {+ 'score': self.to_decimal(cb_data.get('competence_index', 0.5)),+ 'components': ['Staff expertise', 'Research capability', 'Analysis quality'],+ 'importance': 'Effective policy design and implementation'+ }+ }++ overall_quality = sum(metric['score'] for metric in quality_metrics.values()) / self.to_decimal(4)++ return {+ 'quality_metrics': quality_metrics,+ 'overall_quality_score': overall_quality,+ 'effectiveness_rating': self._rate_effectiveness(overall_quality),+ 'improvement_recommendations': self._recommend_improvements(quality_metrics)+ }++ def _rate_effectiveness(self, score: Decimal) -> str:+ """Rate central bank effectiveness"""+ if score > self.to_decimal(0.8):+ return 'Highly Effective'+ elif score > self.to_decimal(0.6):+ return 'Effective'+ elif score > self.to_decimal(0.4):+ return 'Moderately Effective'+ else:+ return 'Needs Improvement'++ def _recommend_improvements(self, metrics: Dict[str, Any]) -> List[str]:+ """Recommend improvements based on quality metrics"""+ recommendations = []++ for metric, data in metrics.items():+ if data['score'] < self.to_decimal(0.6):+ if metric == 'independence':+ recommendations.append('Strengthen legal framework for central bank independence')+ elif metric == 'transparency':+ recommendations.append('Improve communication strategy and public reporting')+ elif metric == 'accountability':+ recommendations.append('Enhance oversight mechanisms and performance targets')+ elif metric == 'technical_competence':+ recommendations.append('Invest in staff training and research capabilities')++ return recommendations++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate central bank quality assessment"""+ result = self.assess_central_bank_quality(kwargs.get('cb_data', {}))+ result['metadata'] = self.get_metadata()+ return result\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/reporting.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/reporting.pynew file mode 100644index 000000000..6cbd08ce1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/reporting.py@@ -0,0 +1,507 @@++Economic Reporting Module+=============================++Economic analysis reporting and visualization++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++import pandas as pd+import numpy as np+import matplotlib.pyplot as plt+import seaborn as sns+from decimal import Decimal+from typing import Dict, List, Optional, Any, Union+from datetime import datetime+import json+import warnings+from .core import EconomicsBase, ValidationError++warnings.filterwarnings('ignore')+plt.style.use('seaborn-v0_8')+++class VisualizationEngine(EconomicsBase):+ """Advanced visualization for economic analysis"""++ def __init__(self, precision: int = 8):+ super().__init__(precision)+ self.default_figsize = (12, 8)+ self.color_palette = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd']++ def plot_time_series(self, data: pd.DataFrame, title: str = "Time Series Analysis",+ figsize: tuple = None) -> Dict[str, Any]:+ """Create professional time series plots"""++ if not isinstance(data.index, pd.DatetimeIndex):+ raise ValidationError("Data must have datetime index")++ figsize = figsize or self.default_figsize+ fig, axes = plt.subplots(2, 2, figsize=(figsize[0], figsize[1] * 1.2))+ fig.suptitle(title, fontsize=16, fontweight='bold')++ # Main time series plot+ ax1 = axes[0, 0]+ for i, col in enumerate(data.columns[:5]): # Max 5 series+ ax1.plot(data.index, data[col], label=col,+ color=self.color_palette[i % len(self.color_palette)], linewidth=2)+ ax1.set_title('Time Series Data')+ ax1.legend()+ ax1.grid(True, alpha=0.3)++ # Returns plot+ ax2 = axes[0, 1]+ returns = data.pct_change().dropna()+ if not returns.empty:+ ax2.plot(returns.index, returns.iloc[:, 0],+ color=self.color_palette[0], linewidth=1, alpha=0.7)+ ax2.set_title('Returns')+ ax2.grid(True, alpha=0.3)++ # Distribution plot+ ax3 = axes[1, 0]+ if not returns.empty:+ ax3.hist(returns.iloc[:, 0].dropna(), bins=30, alpha=0.7,+ color=self.color_palette[0], edgecolor='black')+ ax3.set_title('Returns Distribution')+ ax3.set_xlabel('Returns')+ ax3.set_ylabel('Frequency')++ # Autocorrelation plot+ ax4 = axes[1, 1]+ try:+ from statsmodels.tsa.stattools import acf+ if len(data.iloc[:, 0].dropna()) > 20:+ lags = min(20, len(data) // 4)+ autocorr = acf(data.iloc[:, 0].dropna(), nlags=lags)+ ax4.bar(range(len(autocorr)), autocorr, alpha=0.7, color=self.color_palette[0])+ ax4.axhline(y=0, color='black', linestyle='-', alpha=0.3)+ ax4.set_title('Autocorrelation')+ ax4.set_xlabel('Lags')+ except ImportError:+ ax4.text(0.5, 0.5, 'Autocorrelation\nrequires statsmodels',+ ha='center', va='center', transform=ax4.transAxes)++ plt.tight_layout()+ return {'figure': fig, 'plot_type': 'time_series'}++ def plot_correlation_matrix(self, corr_matrix: pd.DataFrame,+ title: str = "Correlation Matrix") -> Dict[str, Any]:+ """Create correlation heatmap"""++ fig, ax = plt.subplots(figsize=self.default_figsize)++ # Create heatmap+ sns.heatmap(corr_matrix, annot=True, cmap='RdYlBu_r', center=0,+ square=True, fmt='.2f', cbar_kws={'label': 'Correlation'})++ ax.set_title(title, fontsize=16, fontweight='bold', pad=20)+ plt.tight_layout()++ return {'figure': fig, 'plot_type': 'correlation_heatmap'}++ def plot_economic_indicators(self, data: Dict[str, pd.Series],+ title: str = "Economic Indicators") -> Dict[str, Any]:+ """Plot multiple economic indicators with subplots"""++ n_indicators = len(data)+ if n_indicators == 0:+ raise ValidationError("No data provided")++ # Determine subplot layout+ if n_indicators <= 2:+ rows, cols = 1, n_indicators+ elif n_indicators <= 4:+ rows, cols = 2, 2+ else:+ rows, cols = 3, 3++ fig, axes = plt.subplots(rows, cols, figsize=(cols * 6, rows * 4))+ if n_indicators == 1:+ axes = [axes]+ elif rows == 1 or cols == 1:+ axes = axes.flatten()+ else:+ axes = axes.flatten()++ fig.suptitle(title, fontsize=16, fontweight='bold')++ for i, (indicator, series) in enumerate(data.items()):+ if i >= len(axes):+ break++ ax = axes[i]+ ax.plot(series.index, series.values,+ color=self.color_palette[i % len(self.color_palette)], linewidth=2)+ ax.set_title(indicator)+ ax.grid(True, alpha=0.3)++ # Add trend line+ if len(series) > 2:+ z = np.polyfit(range(len(series)), series.values, 1)+ trend = np.poly1d(z)+ ax.plot(series.index, trend(range(len(series))),+ '--', alpha=0.7, color='red', linewidth=1)++ # Hide unused subplots+ for i in range(n_indicators, len(axes)):+ axes[i].set_visible(False)++ plt.tight_layout()+ return {'figure': fig, 'plot_type': 'economic_indicators'}++ def plot_forecast(self, historical: pd.Series, forecast: List[float],+ confidence_intervals: Optional[Dict[str, List[float]]] = None,+ title: str = "Forecast Analysis") -> Dict[str, Any]:+ """Plot forecast with confidence intervals"""++ fig, ax = plt.subplots(figsize=self.default_figsize)++ # Plot historical data+ ax.plot(historical.index, historical.values,+ label='Historical', color=self.color_palette[0], linewidth=2)++ # Create forecast index+ last_date = historical.index[-1]+ if isinstance(last_date, pd.Timestamp):+ freq = pd.infer_freq(historical.index) or 'D'+ forecast_index = pd.date_range(start=last_date + pd.Timedelta(freq),+ periods=len(forecast), freq=freq)+ else:+ forecast_index = range(len(historical), len(historical) + len(forecast))++ # Plot forecast+ ax.plot(forecast_index, forecast,+ label='Forecast', color=self.color_palette[1], linewidth=2, linestyle='--')++ # Plot confidence intervals+ if confidence_intervals:+ lower = confidence_intervals.get('lower', [])+ upper = confidence_intervals.get('upper', [])+ if len(lower) == len(forecast) and len(upper) == len(forecast):+ ax.fill_between(forecast_index, lower, upper,+ alpha=0.3, color=self.color_palette[1], label='95% CI')++ ax.set_title(title, fontsize=16, fontweight='bold')+ ax.legend()+ ax.grid(True, alpha=0.3)+ plt.tight_layout()++ return {'figure': fig, 'plot_type': 'forecast'}+++class ReportGenerator(EconomicsBase):+ """Generate comprehensive analysis reports"""++ def __init__(self, precision: int = 8):+ super().__init__(precision)+ self.viz_engine = VisualizationEngine(precision)++ def generate_analysis_report(self, analysis_results: Dict[str, Any],+ report_title: str = "Economic Analysis Report") -> Dict[str, Any]:+ """Generate comprehensive analysis report"""++ report = {+ 'title': report_title,+ 'generated_at': datetime.now().isoformat(),+ 'summary': self._generate_executive_summary(analysis_results),+ 'sections': {},+ 'visualizations': [],+ 'recommendations': self._generate_recommendations(analysis_results)+ }++ # Process different analysis types+ for analysis_type, results in analysis_results.items():+ if 'error' in str(results):+ continue++ section = self._create_analysis_section(analysis_type, results)+ if section:+ report['sections'][analysis_type] = section++ return report++ def _generate_executive_summary(self, results: Dict[str, Any]) -> Dict[str, Any]:+ """Generate executive summary from analysis results"""++ summary = {+ 'key_findings': [],+ 'risk_assessment': 'Not Available',+ 'outlook': 'Neutral',+ 'confidence_level': 'Medium'+ }++ # Extract key findings from various analyses+ for analysis_type, analysis_results in results.items():+ if isinstance(analysis_results, dict) and 'error' not in analysis_results:++ if 'correlation' in analysis_type.lower():+ high_corr = analysis_results.get('highest_correlations', [])+ if high_corr:+ summary['key_findings'].append(+ f"Highest correlation: {high_corr[0]['variable_1']} - {high_corr[0]['variable_2']} ({float(high_corr[0]['correlation']):.3f})"+ )++ elif 'forecast' in analysis_type.lower():+ forecasts = analysis_results.get('forecasts', {})+ if forecasts:+ best_method = analysis_results.get('evaluation', {}).get('best_method', 'Unknown')+ summary['key_findings'].append(f"Best forecasting method: {best_method}")++ elif 'monte_carlo' in analysis_type.lower():+ risk_metrics = analysis_results.get('risk_metrics', {})+ if risk_metrics:+ var_95 = risk_metrics.get('var_95')+ if var_95:+ summary['key_findings'].append(f"95% VaR: {float(var_95):.2f}")++ return summary++ def _create_analysis_section(self, analysis_type: str, results: Dict[str, Any]) -> Optional[Dict[str, Any]]:+ """Create report section for specific analysis type"""++ section = {+ 'title': analysis_type.replace('_', ' ').title(),+ 'content': {},+ 'key_metrics': {},+ 'interpretation': ''+ }++ if 'statistical' in analysis_type:+ stats = results.get('basic_statistics', {})+ section['key_metrics'] = {+ 'Mean': stats.get('mean'),+ 'Std Dev': stats.get('standard_deviation'),+ 'Skewness': stats.get('skewness'),+ 'Kurtosis': stats.get('kurtosis')+ }+ section['interpretation'] = self._interpret_statistics(stats)++ elif 'correlation' in analysis_type:+ section['key_metrics'] = {+ 'Mean Correlation': results.get('summary_statistics', {}).get('mean_correlation'),+ 'Max Correlation': results.get('summary_statistics', {}).get('max_correlation'),+ 'Significant Pairs': len(results.get('significant_correlations', []))+ }++ elif 'forecast' in analysis_type:+ evaluation = results.get('evaluation', {})+ if evaluation:+ best_method = evaluation.get('best_method', 'Unknown')+ section['key_metrics'] = {+ 'Best Method': best_method,+ 'Forecast Periods': results.get('forecast_periods', 0)+ }++ section['content'] = results+ return section++ def _interpret_statistics(self, stats: Dict[str, Any]) -> str:+ """Generate interpretation of statistical results"""++ interpretations = []++ skewness = stats.get('skewness')+ if skewness:+ skew_val = float(skewness)+ if abs(skew_val) < 0.5:+ interpretations.append("Distribution is approximately symmetric")+ elif skew_val > 0.5:+ interpretations.append("Distribution is positively skewed (right tail)")+ else:+ interpretations.append("Distribution is negatively skewed (left tail)")++ kurtosis = stats.get('kurtosis')+ if kurtosis:+ kurt_val = float(kurtosis)+ if kurt_val > 3:+ interpretations.append("Distribution has heavy tails (leptokurtic)")+ elif kurt_val < 3:+ interpretations.append("Distribution has light tails (platykurtic)")++ return ". ".join(interpretations) + "." if interpretations else "No specific interpretation available."++ def _generate_recommendations(self, results: Dict[str, Any]) -> List[str]:+ """Generate actionable recommendations"""++ recommendations = []++ for analysis_type, analysis_results in results.items():+ if isinstance(analysis_results, dict) and 'error' not in analysis_results:++ if 'risk' in analysis_type.lower():+ recommendations.append("Monitor risk metrics regularly and adjust exposure accordingly")++ elif 'correlation' in analysis_type.lower():+ recommendations.append("Consider correlation relationships for portfolio diversification")++ elif 'forecast' in analysis_type.lower():+ recommendations.append("Use multiple forecasting methods and update predictions regularly")++ if not recommendations:+ recommendations = ["Continue monitoring economic indicators and market conditions"]++ return recommendations+++class ExportManager(EconomicsBase):+ """Export analysis results to various formats"""++ def __init__(self, precision: int = 8):+ super().__init__(precision)++ def export_to_json(self, data: Dict[str, Any], file_path: str = None) -> str:+ """Export results to JSON format"""++ # Convert Decimal objects to float for JSON serialization+ json_data = self._prepare_for_json(data)++ json_str = json.dumps(json_data, indent=2, default=self._json_serializer)++ if file_path:+ with open(file_path, 'w') as f:+ f.write(json_str)++ return json_str++ def export_to_excel(self, data: Dict[str, Any], file_path: str) -> bool:+ """Export results to Excel format"""++ try:+ with pd.ExcelWriter(file_path, engine='openpyxl') as writer:++ # Export summary data+ summary_data = []+ for key, value in data.items():+ if isinstance(value, (str, int, float, Decimal)):+ summary_data.append(+ {'Metric': key, 'Value': float(value) if isinstance(value, Decimal) else value})++ if summary_data:+ pd.DataFrame(summary_data).to_excel(writer, sheet_name='Summary', index=False)++ # Export detailed data+ for section_name, section_data in data.items():+ if isinstance(section_data, dict):+ try:+ df = pd.DataFrame(section_data)+ if not df.empty:+ # Clean sheet name+ sheet_name = section_name.replace('_', ' ').title()[:31]+ df.to_excel(writer, sheet_name=sheet_name, index=True)+ except:+ continue++ return True++ except Exception as e:+ raise ValidationError(f"Error exporting to Excel: {e}")++ def _prepare_for_json(self, obj: Any) -> Any:+ """Prepare object for JSON serialization"""++ if isinstance(obj, dict):+ return {key: self._prepare_for_json(value) for key, value in obj.items()}+ elif isinstance(obj, list):+ return [self._prepare_for_json(item) for item in obj]+ elif isinstance(obj, Decimal):+ return float(obj)+ elif isinstance(obj, (pd.Timestamp, datetime)):+ return obj.isoformat()+ elif isinstance(obj, pd.Series):+ return obj.to_dict()+ elif isinstance(obj, pd.DataFrame):+ return obj.to_dict('records')+ else:+ return obj++ def _json_serializer(self, obj: Any) -> Any:+ """Custom JSON serializer for special objects"""++ if isinstance(obj, (pd.Timestamp, datetime)):+ return obj.isoformat()+ elif isinstance(obj, Decimal):+ return float(obj)+ elif hasattr(obj, 'tolist'): # numpy arrays+ return obj.tolist()+ else:+ return str(obj)++ def generate_pdf_summary(self, analysis_report: Dict[str, Any],+ file_path: str = None) -> str:+ """Generate PDF summary report"""++ # Simple text-based summary for PDF generation+ summary_text = f"""+ECONOMIC ANALYSIS REPORT+{analysis_report.get('title', 'Analysis Report')}+Generated: {analysis_report.get('generated_at', 'Unknown')}++EXECUTIVE SUMMARY+{'-' * 50}+"""++ summary = analysis_report.get('summary', {})++ # Key findings+ findings = summary.get('key_findings', [])+ if findings:+ summary_text += "\nKey Findings:\n"+ for finding in findings:+ summary_text += f"• {finding}\n"++ # Risk assessment+ risk = summary.get('risk_assessment', 'Not Available')+ summary_text += f"\nRisk Assessment: {risk}\n"++ # Outlook+ outlook = summary.get('outlook', 'Neutral')+ summary_text += f"Outlook: {outlook}\n"++ # Recommendations+ recommendations = analysis_report.get('recommendations', [])+ if recommendations:+ summary_text += f"\nRECOMMENDATIONS\n{'-' * 50}\n"+ for i, rec in enumerate(recommendations, 1):+ summary_text += f"{i}. {rec}\n"++ if file_path:+ with open(file_path, 'w') as f:+ f.write(summary_text)++ return summary_text++ def calculate(self, export_type: str, **kwargs) -> Any:+ """Main export dispatcher"""++ exports = {+ 'json': lambda: self.export_to_json(kwargs['data'], kwargs.get('file_path')),+ 'excel': lambda: self.export_to_excel(kwargs['data'], kwargs['file_path']),+ 'pdf_summary': lambda: self.generate_pdf_summary(kwargs['data'], kwargs.get('file_path'))+ }++ if export_type not in exports:+ raise ValidationError(f"Unknown export type: {export_type}")++ return exports[export_type]()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/trade_geopolitics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/trade_geopolitics.pynew file mode 100644index 000000000..b58415deb--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/economics/trade_geopolitics.py@@ -0,0 +1,842 @@++Economic Trade Geopolitics Module+=============================++Trade and geopolitical risk analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Macroeconomic time series data from official sources+ - Central bank policy statements and interest rate data+ - International trade and balance of payments statistics+ - Market indicators and sentiment measures+ - Demographic and structural economic data++OUTPUT:+ - Economic trend analysis and forecasts+ - Policy impact assessment and scenario modeling+ - Market cycle identification and timing analysis+ - Cross-country economic comparisons and rankings+ - Investment recommendations based on economic outlook++PARAMETERS:+ - forecast_horizon: Economic forecast horizon (default: 12 months)+ - confidence_level: Confidence level for predictions (default: 0.90)+ - base_currency: Base currency for analysis (default: 'USD')+ - seasonal_adjustment: Seasonal adjustment method (default: true)+ - lookback_period: Historical analysis period (default: 10 years)+++from decimal import Decimal+from typing import Dict, List, Any, Tuple+from .core import EconomicsBase, ValidationError+++class TradeAnalyzer(EconomicsBase):+ """International trade analysis and policy assessment"""++ def analyze_trade_benefits_costs(self, trade_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze benefits and costs of international trade"""+ return {+ 'trade_benefits': {+ 'efficiency_gains': {+ 'comparative_advantage': 'Countries specialize in relative strengths',+ 'resource_allocation': 'More efficient global resource use',+ 'scale_economies': 'Larger markets enable economies of scale',+ 'quantitative_benefit': self._calculate_trade_gains(trade_data)+ },+ 'consumer_benefits': {+ 'variety': 'Greater product variety and choice',+ 'lower_prices': 'Increased competition reduces prices',+ 'quality_improvement': 'Competition drives quality improvements',+ 'consumer_surplus_gain': self._estimate_consumer_surplus_gain(trade_data)+ },+ 'growth_benefits': {+ 'technology_transfer': 'Access to foreign technology and knowledge',+ 'productivity_spillovers': 'Learning from foreign competition',+ 'investment_flows': 'Foreign direct investment attraction',+ 'innovation_incentives': 'Competition spurs innovation'+ }+ },+ 'trade_costs': {+ 'adjustment_costs': {+ 'job_displacement': 'Workers in import-competing industries lose jobs',+ 'regional_impacts': 'Concentrated effects in specific regions',+ 'skill_premiums': 'Wage gaps between skilled/unskilled workers',+ 'adjustment_period': 'Time and cost of worker reallocation'+ },+ 'distributional_effects': {+ 'income_inequality': 'May worsen within-country inequality',+ 'factor_returns': 'Changes in wages, profits, land rents',+ 'sectoral_shifts': 'Decline of import-competing sectors',+ 'compensation_needs': 'Required support for affected workers'+ },+ 'vulnerability_risks': {+ 'import_dependence': 'Reliance on foreign suppliers',+ 'economic_security': 'Potential supply chain disruptions',+ 'policy_autonomy': 'Constraints on domestic policy flexibility'+ }+ },+ 'net_welfare_assessment': self._assess_net_welfare_impact(trade_data)+ }++ def analyze_trade_restrictions(self, restriction_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze different types of trade restrictions and their impacts"""+ return {+ 'tariffs': {+ 'mechanism': 'Tax on imports',+ 'economic_effects': self._analyze_tariff_effects(restriction_data.get('tariff_rate', 0)),+ 'revenue_generation': 'Provides government revenue',+ 'protection_level': 'Proportional to tariff rate',+ 'welfare_impact': 'Net welfare loss (deadweight loss)'+ },+ 'quotas': {+ 'mechanism': 'Quantity limit on imports',+ 'economic_effects': self._analyze_quota_effects(restriction_data.get('quota_volume', 0)),+ 'revenue_generation': 'No government revenue (quota rents to importers)',+ 'protection_level': 'Fixed quantity protection',+ 'welfare_impact': 'Similar to tariffs but different rent distribution'+ },+ 'export_subsidies': {+ 'mechanism': 'Government payments to exporters',+ 'economic_effects': self._analyze_subsidy_effects(restriction_data.get('subsidy_rate', 0)),+ 'revenue_generation': 'Costs government revenue',+ 'protection_level': 'Supports domestic producers',+ 'welfare_impact': 'Welfare loss in subsidizing country'+ },+ 'non_tariff_barriers': {+ 'types': ['Technical standards', 'Sanitary measures', 'Administrative procedures'],+ 'effects': 'Hidden protection, often more restrictive than tariffs',+ 'measurement_difficulty': 'Hard to quantify economic impact',+ 'welfare_impact': 'Potentially large welfare costs'+ },+ 'restriction_comparison': self._compare_trade_restrictions(),+ 'optimal_policy_recommendation': self._recommend_trade_policy(restriction_data)+ }++ def analyze_trading_blocs(self, bloc_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze trading blocs, common markets, and economic unions"""+ integration_types = {+ 'free_trade_area': {+ 'definition': 'Eliminate tariffs among members, keep individual external tariffs',+ 'examples': ['NAFTA/USMCA', 'ASEAN FTA'],+ 'advantages': ['Trade creation', 'Market access', 'Political cooperation'],+ 'disadvantages': ['Trade diversion', 'Rules of origin complexity'],+ 'economic_impact': self._assess_fta_impact(bloc_data)+ },+ 'customs_union': {+ 'definition': 'Free trade area plus common external tariff',+ 'examples': ['EU Customs Union', 'Mercosur'],+ 'advantages': ['Eliminates trade deflection', 'Stronger negotiating power'],+ 'disadvantages': ['Loss of tariff autonomy', 'Complex revenue sharing'],+ 'economic_impact': self._assess_customs_union_impact(bloc_data)+ },+ 'common_market': {+ 'definition': 'Customs union plus free movement of factors',+ 'examples': ['EU Single Market', 'ECOWAS'],+ 'advantages': ['Factor mobility benefits', 'Efficiency gains', 'Scale economies'],+ 'disadvantages': ['Adjustment pressures', 'Migration concerns', 'Policy coordination needs'],+ 'economic_impact': self._assess_common_market_impact(bloc_data)+ },+ 'economic_union': {+ 'definition': 'Common market plus unified economic policies',+ 'examples': ['European Union', 'Proposed ASEAN Economic Community'],+ 'advantages': ['Maximum integration benefits', 'Policy coherence', 'Stability'],+ 'disadvantages': ['Sovereignty loss', 'Complex governance', 'Asymmetric effects'],+ 'economic_impact': self._assess_economic_union_impact(bloc_data)+ }+ }++ return {+ 'integration_levels': integration_types,+ 'motivations_for_integration': self._analyze_integration_motivations(),+ 'success_factors': self._identify_integration_success_factors(),+ 'trade_creation_vs_diversion': self._analyze_trade_creation_diversion(bloc_data)+ }++ def assess_trade_barrier_removal(self, liberalization_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess impact of removing trade barriers"""+ return {+ 'capital_investment_effects': {+ 'foreign_direct_investment': {+ 'expected_change': 'Significant increase',+ 'mechanisms': ['Market access', 'Lower costs', 'Efficiency seeking'],+ 'sectoral_impact': 'Manufacturing and services benefit most',+ 'quantitative_estimate': self._estimate_fdi_increase(liberalization_data)+ },+ 'domestic_investment': {+ 'expected_change': 'Mixed effects',+ 'mechanisms': ['Competitive pressure', 'Technology access', 'Scale opportunities'],+ 'adjustment_period': '3-7 years for full effects',+ 'productivity_gains': self._estimate_productivity_gains(liberalization_data)+ }+ },+ 'employment_wage_effects': {+ 'aggregate_employment': {+ 'short_term': 'May decline due to adjustment',+ 'long_term': 'Likely increase from higher productivity',+ 'skill_composition': 'Shift toward higher-skilled jobs',+ 'quantitative_estimate': self._estimate_employment_effects(liberalization_data)+ },+ 'wage_effects': {+ 'average_wages': 'Generally increase over time',+ 'wage_distribution': 'May increase inequality initially',+ 'sectoral_variation': 'Export sectors gain, import-competing sectors lose',+ 'skill_premium_changes': self._analyze_skill_premium_effects(liberalization_data)+ }+ },+ 'growth_effects': {+ 'gdp_impact': {+ 'magnitude': self._estimate_gdp_impact(liberalization_data),+ 'channels': ['Productivity', 'Investment', 'Competition', 'Innovation'],+ 'time_horizon': 'Full effects realized over 10-15 years',+ 'persistence': 'Permanent level effects, temporary growth effects'+ },+ 'sectoral_growth': self._analyze_sectoral_growth_effects(liberalization_data),+ 'regional_effects': self._assess_regional_impact_variation(liberalization_data)+ },+ 'policy_recommendations': self._recommend_liberalization_policies(liberalization_data)+ }++ def _calculate_trade_gains(self, data: Dict[str, Any]) -> Decimal:+ """Calculate quantitative trade gains"""+ trade_volume = self.to_decimal(data.get('trade_volume_gdp', 0))+ efficiency_gain = self.to_decimal(0.05) # Typical 5% efficiency gain+ return trade_volume * efficiency_gain++ def _estimate_consumer_surplus_gain(self, data: Dict[str, Any]) -> Decimal:+ """Estimate consumer surplus gains from trade"""+ price_reduction = self.to_decimal(data.get('price_reduction_percent', 5))+ consumption_share = self.to_decimal(data.get('traded_goods_consumption', 30))+ return price_reduction * consumption_share / self.to_decimal(200) # Simplified calculation++ def _analyze_tariff_effects(self, tariff_rate: float) -> Dict[str, Any]:+ """Analyze economic effects of tariffs"""+ rate = self.to_decimal(tariff_rate)+ return {+ 'price_increase': f"Domestic price rises by approximately {rate}%",+ 'import_reduction': f"Imports fall by {rate * self.to_decimal(1.5)}% (assuming elasticity 1.5)",+ 'domestic_production': f"Domestic production increases by {rate * self.to_decimal(0.8)}%",+ 'welfare_loss': f"Deadweight loss approximately {rate ** 2 / self.to_decimal(200)}% of GDP"+ }++ def _analyze_quota_effects(self, quota_volume: float) -> Dict[str, Any]:+ """Analyze economic effects of import quotas"""+ return {+ 'price_effect': 'Domestic price rises to clear market at quota level',+ 'quantity_certainty': 'Import volume fixed regardless of demand changes',+ 'rent_distribution': 'Quota rents accrue to license holders',+ 'supply_response': 'Domestic producers expand to fill demand gap'+ }++ def _analyze_subsidy_effects(self, subsidy_rate: float) -> Dict[str, Any]:+ """Analyze economic effects of export subsidies"""+ rate = self.to_decimal(subsidy_rate)+ return {+ 'export_increase': f"Exports rise by approximately {rate * self.to_decimal(1.2)}%",+ 'domestic_price_rise': f"Domestic price increases by {rate * self.to_decimal(0.5)}%",+ 'fiscal_cost': f"Government cost {rate}% of export value",+ 'foreign_welfare': 'Foreign consumers benefit from lower prices'+ }++ def _compare_trade_restrictions(self) -> Dict[str, str]:+ """Compare different trade restriction types"""+ return {+ 'transparency': 'Tariffs > Quotas > Non-tariff barriers',+ 'revenue_generation': 'Tariffs > Export subsidies (cost) > Quotas (no revenue)',+ 'welfare_impact': 'All create deadweight losses, magnitude varies',+ 'administrative_burden': 'Non-tariff barriers > Quotas > Tariffs',+ 'flexibility': 'Tariffs > Export subsidies > Quotas'+ }++ def _recommend_trade_policy(self, data: Dict[str, Any]) -> str:+ """Recommend optimal trade policy"""+ development_level = data.get('development_level', 'middle')+ industry_maturity = data.get('industry_maturity', 'mature')++ if development_level == 'developing' and industry_maturity == 'infant':+ return 'Temporary protection may be justified for infant industries'+ elif development_level == 'developed':+ return 'Free trade generally optimal for developed economies'+ else:+ return 'Gradual liberalization with adjustment assistance'++ def _assess_fta_impact(self, data: Dict[str, Any]) -> str:+ """Assess free trade agreement impact"""+ trade_creation = self.to_decimal(data.get('trade_creation', 0))+ trade_diversion = self.to_decimal(data.get('trade_diversion', 0))++ if trade_creation > trade_diversion:+ return 'Net welfare gain from trade creation effects'+ else:+ return 'Potential welfare loss from trade diversion'++ def _assess_customs_union_impact(self, data: Dict[str, Any]) -> str:+ """Assess customs union impact"""+ return 'Generally more beneficial than FTA due to common external tariff'++ def _assess_common_market_impact(self, data: Dict[str, Any]) -> str:+ """Assess common market impact"""+ return 'Significant benefits from factor mobility, but requires strong institutions'++ def _assess_economic_union_impact(self, data: Dict[str, Any]) -> str:+ """Assess economic union impact"""+ return 'Maximum benefits but requires political integration and sovereignty transfer'++ def _analyze_integration_motivations(self) -> List[str]:+ """Analyze motivations for regional integration"""+ return [+ 'Economic: Market access, scale economies, efficiency gains',+ 'Political: Peace, cooperation, international influence',+ 'Strategic: Counterbalance to other blocs, bargaining power',+ 'Development: Technology transfer, investment attraction'+ ]++ def _identify_integration_success_factors(self) -> List[str]:+ """Identify factors for successful regional integration"""+ return [+ 'Geographic proximity and cultural similarity',+ 'Similar development levels and economic structures',+ 'Political commitment and institutional capacity',+ 'Complementary rather than competing economies',+ 'Mechanism for handling adjustment costs'+ ]++ def _analyze_trade_creation_diversion(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze trade creation vs trade diversion effects"""+ return {+ 'trade_creation': {+ 'definition': 'New trade due to elimination of barriers among members',+ 'welfare_effect': 'Positive - increases efficiency',+ 'mechanism': 'Efficient producers replace inefficient domestic production'+ },+ 'trade_diversion': {+ 'definition': 'Trade shifts from efficient non-members to less efficient members',+ 'welfare_effect': 'Negative - reduces efficiency',+ 'mechanism': 'Preferential access distorts comparative advantage'+ },+ 'net_effect': 'Depends on relative magnitude of creation vs diversion'+ }++ def _estimate_fdi_increase(self, data: Dict[str, Any]) -> str:+ """Estimate FDI increase from liberalization"""+ liberalization_scope = data.get('liberalization_scope', 'moderate')++ increases = {+ 'limited': '20-40% increase over 5 years',+ 'moderate': '50-100% increase over 5 years',+ 'comprehensive': '100-200% increase over 5 years'+ }++ return increases.get(liberalization_scope, '50-100% increase over 5 years')++ def _estimate_productivity_gains(self, data: Dict[str, Any]) -> str:+ """Estimate productivity gains from liberalization"""+ return '2-5% productivity gain over 5-10 years'++ def _estimate_employment_effects(self, data: Dict[str, Any]) -> str:+ """Estimate employment effects of liberalization"""+ return 'Short-term adjustment costs, long-term employment gains'++ def _analyze_skill_premium_effects(self, data: Dict[str, Any]) -> str:+ """Analyze effects on skill premiums"""+ return 'Skill premium may increase initially, then stabilize with education/training'++ def _estimate_gdp_impact(self, data: Dict[str, Any]) -> str:+ """Estimate GDP impact of trade liberalization"""+ return '1-3% permanent GDP level increase, spread over 10-15 years'++ def _analyze_sectoral_growth_effects(self, data: Dict[str, Any]) -> Dict[str, str]:+ """Analyze sectoral growth effects"""+ return {+ 'export_sectors': 'Strong growth, increased investment',+ 'import_competing_sectors': 'Decline, but may become more efficient',+ 'service_sectors': 'Generally benefit from lower input costs',+ 'technology_sectors': 'Benefit from knowledge spillovers'+ }++ def _assess_regional_impact_variation(self, data: Dict[str, Any]) -> str:+ """Assess regional variation in impacts"""+ return 'Urban areas and regions with comparative advantage benefit most'++ def _recommend_liberalization_policies(self, data: Dict[str, Any]) -> List[str]:+ """Recommend supporting policies for liberalization"""+ return [+ 'Trade adjustment assistance for displaced workers',+ 'Education and training programs for skill upgrading',+ 'Infrastructure investment to support new trade patterns',+ 'Competition policy to ensure domestic market efficiency',+ 'Social safety net to manage transition costs'+ ]++ def _assess_net_welfare_impact(self, data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess net welfare impact of trade"""+ return {+ 'aggregate_welfare': 'Generally positive but distribution matters',+ 'time_dimension': 'Short-term costs, long-term benefits',+ 'policy_implications': 'Need complementary policies for inclusive growth',+ 'measurement_challenges': 'Difficult to quantify all benefits and costs'+ }++ def calculate(self, analysis_type: str = 'benefits_costs', **kwargs) -> Dict[str, Any]:+ """Main trade analysis dispatcher"""+ analyses = {+ 'benefits_costs': lambda: self.analyze_trade_benefits_costs(kwargs.get('trade_data', {})),+ 'restrictions': lambda: self.analyze_trade_restrictions(kwargs.get('restriction_data', {})),+ 'trading_blocs': lambda: self.analyze_trading_blocs(kwargs.get('bloc_data', {})),+ 'barrier_removal': lambda: self.assess_trade_barrier_removal(kwargs.get('liberalization_data', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class GeopoliticalRiskAnalyzer(EconomicsBase):+ """Geopolitical risk assessment and investment implications"""++ def analyze_geopolitics_framework(self) -> Dict[str, Any]:+ """Analyze geopolitics from cooperation vs competition perspective"""+ return {+ 'cooperation_perspective': {+ 'drivers': ['Economic interdependence', 'Shared challenges', 'Institutional frameworks'],+ 'mechanisms': ['Trade agreements', 'International organizations', 'Diplomatic engagement'],+ 'benefits': ['Peace dividend', 'Economic gains', 'Global public goods'],+ 'examples': ['EU integration', 'WTO system', 'Climate cooperation']+ },+ 'competition_perspective': {+ 'drivers': ['National interests', 'Power struggles', 'Resource competition'],+ 'mechanisms': ['Military buildup', 'Economic sanctions', 'Technology competition'],+ 'risks': ['Conflict escalation', 'Economic fragmentation', 'Arms races'],+ 'examples': ['US-China rivalry', 'Russia-West tensions', 'Cyber warfare']+ },+ 'cooperation_competition_spectrum': {+ 'coopetition': 'Simultaneous cooperation and competition',+ 'issue_specificity': 'Cooperation on some issues, competition on others',+ 'temporal_variation': 'Shifting between cooperation and competition over time',+ 'stakeholder_differences': 'Different actors may prefer different approaches'+ },+ 'current_global_trends': self._assess_current_geopolitical_trends()+ }++ def analyze_geopolitics_globalization(self) -> Dict[str, Any]:+ """Analyze relationship between geopolitics and globalization"""+ return {+ 'globalization_drivers': {+ 'economic': 'Trade, investment, financial integration',+ 'technological': 'Communication, transportation, digital connectivity',+ 'political': 'International governance, regulatory convergence',+ 'cultural': 'Information flow, cultural exchange, migration'+ },+ 'geopolitical_constraints': {+ 'sovereignty_concerns': 'National autonomy vs global integration',+ 'security_considerations': 'Economic interdependence vs strategic autonomy',+ 'distributional_effects': 'Winners and losers from globalization',+ 'cultural_resistance': 'Preserving national identity and values'+ },+ 'interaction_dynamics': {+ 'reinforcing_effects': 'Economic integration can reduce conflict incentives',+ 'tension_creation': 'Globalization can threaten traditional power structures',+ 'policy_responses': 'Governments balance integration with national interests',+ 'cyclical_patterns': 'Periods of integration followed by fragmentation'+ },+ 'current_deglobalization_trends': self._analyze_deglobalization_trends()+ }++ def analyze_international_organizations(self) -> Dict[str, Any]:+ """Analyze functions and objectives of key international organizations"""+ return {+ 'world_bank': {+ 'primary_objective': 'Reduce poverty and promote shared prosperity',+ 'functions': [+ 'Development financing and technical assistance',+ 'Policy advice and capacity building',+ 'Knowledge sharing and research',+ 'Crisis response and post-conflict reconstruction'+ ],+ 'lending_instruments': ['IBRD loans', 'IDA grants', 'Private sector lending'],+ 'governance': '189 member countries, voting power based on capital contributions',+ 'effectiveness_assessment': 'Mixed results, criticism for conditionality and governance'+ },+ 'international_monetary_fund': {+ 'primary_objective': 'Ensure stability of international monetary system',+ 'functions': [+ 'Surveillance of global economy and exchange rates',+ 'Financial assistance to countries in balance of payments difficulties',+ 'Technical assistance and capacity development',+ 'Standard setting and policy coordination'+ ],+ 'lending_facilities': ['Stand-by arrangements', 'Extended fund facility', 'Emergency assistance'],+ 'governance': '190 member countries, quota-based voting system',+ 'effectiveness_assessment': 'Critical role in crisis response, debates over conditionality'+ },+ 'world_trade_organization': {+ 'primary_objective': 'Promote free and fair trade globally',+ 'functions': [+ 'Trade rule making and negotiation',+ 'Dispute settlement between members',+ 'Trade policy monitoring and transparency',+ 'Technical assistance and capacity building'+ ],+ 'key_principles': ['Non-discrimination', 'Market access', 'Fair competition', 'Development'],+ 'governance': '164 members, consensus-based decision making',+ 'effectiveness_assessment': 'Success in trade liberalization, challenges with dispute resolution'+ },+ 'organizational_interactions': self._analyze_organizational_coordination(),+ 'reform_needs': self._assess_reform_requirements()+ }++ def assess_geopolitical_risk(self, risk_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess geopolitical risk levels and components"""+ return {+ 'risk_categories': {+ 'interstate_conflict': {+ 'probability': self._assess_conflict_probability(risk_data),+ 'impact': 'High - disrupts trade, increases defense spending',+ 'indicators': ['Military buildups', 'Territorial disputes', 'Alliance shifts'],+ 'current_hotspots': ['Taiwan Strait', 'Ukraine', 'Middle East', 'South China Sea']+ },+ 'domestic_instability': {+ 'probability': self._assess_instability_probability(risk_data),+ 'impact': 'Medium to High - affects governance and economic policy',+ 'indicators': ['Political polarization', 'Social unrest', 'Economic inequality'],+ 'monitoring_metrics': ['Polity IV scores', 'Fragile States Index', 'Social cohesion indices']+ },+ 'economic_warfare': {+ 'probability': 'Medium - already occurring',+ 'impact': 'High - trade disruption, technology decoupling',+ 'manifestations': ['Trade wars', 'Technology sanctions', 'Financial restrictions'],+ 'current_examples': ['US-China tech competition', 'Russia sanctions', 'Supply chain nationalism']+ },+ 'cyber_threats': {+ 'probability': 'High - ongoing',+ 'impact': 'Medium to High - infrastructure and financial system risks',+ 'evolution': 'Rapidly increasing sophistication and frequency',+ 'mitigation_challenges': 'Attribution difficulties, cross-border nature'+ }+ },+ 'risk_assessment_methodology': self._describe_risk_methodology(),+ 'early_warning_indicators': self._identify_early_warning_signs(),+ 'risk_mitigation_strategies': self._recommend_risk_mitigation()+ }++ def analyze_geopolitical_tools(self) -> Dict[str, Any]:+ """Analyze tools of geopolitics and their economic impact"""+ return {+ 'economic_tools': {+ 'trade_policy': {+ 'instruments': ['Tariffs', 'Quotas', 'Trade agreements', 'Export controls'],+ 'effectiveness': 'High for economic coercion, limited for security goals',+ 'economic_impact': 'Efficiency losses, distributional effects',+ 'examples': ['China trade war', 'Iran sanctions', 'Brexit negotiations']+ },+ 'financial_sanctions': {+ 'instruments': ['Asset freezes', 'Banking restrictions', 'Capital market access'],+ 'effectiveness': 'High when multilateral, moderate when unilateral',+ 'economic_impact': 'Disrupts financial flows, increases transaction costs',+ 'examples': ['Russia SWIFT exclusion', 'Iran banking sanctions', 'North Korea restrictions']+ },+ 'investment_controls': {+ 'instruments': ['FDI screening', 'Technology transfer restrictions',+ 'Sovereign wealth fund limits'],+ 'effectiveness': 'Moderate for strategic sectors',+ 'economic_impact': 'Reduces capital flows, technology diffusion',+ 'examples': ['CFIUS reviews', 'EU FDI screening', 'Technology export controls']+ }+ },+ 'diplomatic_tools': {+ 'multilateral_engagement': 'International organizations and forums',+ 'bilateral_relations': 'Direct government-to-government engagement',+ 'public_diplomacy': 'Cultural and informational influence',+ 'summit_diplomacy': 'High-level leader engagement'+ },+ 'military_tools': {+ 'defense_spending': 'Military buildup and alliance strengthening',+ 'military_presence': 'Forward deployment and bases',+ 'arms_sales': 'Defense cooperation and influence building',+ 'security_assistance': 'Training and capacity building'+ },+ 'tool_effectiveness_comparison': self._compare_geopolitical_tools()+ }++ def assess_investment_implications(self, geopolitical_data: Dict[str, Any]) -> Dict[str, Any]:+ """Assess investment implications of geopolitical risk"""+ return {+ 'asset_class_impacts': {+ 'equities': {+ 'safe_haven_flows': 'Flight to quality during crises',+ 'sector_differentiation': 'Defense up, trade-dependent sectors down',+ 'regional_variation': 'Emerging markets more vulnerable',+ 'volatility_impact': 'Increased uncertainty and volatility'+ },+ 'fixed_income': {+ 'government_bonds': 'Safe haven demand for developed market bonds',+ 'corporate_bonds': 'Credit spreads widen, especially for affected regions',+ 'emerging_market_debt': 'Capital flight and spread widening',+ 'inflation_expectations': 'Supply disruptions may increase inflation'+ },+ 'currencies': {+ 'reserve_currencies': 'Dollar, euro, yen benefit from safe haven flows',+ 'commodity_currencies': 'Impact depends on commodity exposure',+ 'emerging_market_currencies': 'Generally weaken during geopolitical stress',+ 'crypto_currencies': 'Mixed reactions, some safe haven demand'+ },+ 'commodities': {+ 'energy': 'Supply disruption premium for oil and gas',+ 'precious_metals': 'Traditional safe haven demand for gold',+ 'agriculture': 'Supply chain disruptions affect food prices',+ 'industrial_metals': 'Demand reduction from economic slowdown'+ }+ },+ 'sector_analysis': self._analyze_sector_impacts(geopolitical_data),+ 'geographic_considerations': self._assess_geographic_impacts(geopolitical_data),+ 'investment_strategies': self._recommend_investment_strategies(geopolitical_data),+ 'risk_monitoring_framework': self._develop_monitoring_framework()+ }++ def _assess_current_geopolitical_trends(self) -> List[str]:+ """Assess current global geopolitical trends"""+ return [+ 'Rise of China and shifting global power balance',+ 'Renewed great power competition between US, China, and Russia',+ 'Fragmentation of global governance and institutions',+ 'Technology competition and digital sovereignty concerns',+ 'Climate change as a security issue and cooperation challenge',+ 'Democratic backsliding and authoritarian resilience'+ ]++ def _analyze_deglobalization_trends(self) -> Dict[str, str]:+ """Analyze current deglobalization trends"""+ return {+ 'trade_slowdown': 'Growth in global trade relative to GDP has slowed',+ 'supply_chain_reshoring': 'Companies reducing dependence on distant suppliers',+ 'technology_decoupling': 'Separate technology ecosystems emerging',+ 'financial_fragmentation': 'Reduced cross-border capital flows',+ 'immigration_restrictions': 'Tighter controls on human mobility',+ 'policy_implications': 'Governments balancing efficiency with resilience'+ }++ def _analyze_organizational_coordination(self) -> Dict[str, str]:+ """Analyze coordination between international organizations"""+ return {+ 'world_bank_imf': 'Close coordination on development and financial stability',+ 'wto_relationship': 'Limited formal links but complementary mandates',+ 'regional_organizations': 'Growing importance of regional institutions',+ 'coordination_challenges': 'Overlapping mandates and competing priorities'+ }++ def _assess_reform_requirements(self) -> List[str]:+ """Assess reform needs for international organizations"""+ return [+ 'IMF: Quota reform to reflect changing global economy',+ 'World Bank: Climate focus and private sector engagement',+ 'WTO: Dispute settlement reform and digital trade rules',+ 'UN Security Council: Representation reform for emerging powers',+ 'All: Enhanced coordination and reduced overlap'+ ]++ def _assess_conflict_probability(self, data: Dict[str, Any]) -> str:+ """Assess probability of interstate conflict"""+ tension_level = data.get('tension_index', 0.5)++ if tension_level > 0.8:+ return 'High risk of conflict escalation'+ elif tension_level > 0.6:+ return 'Moderate risk, close monitoring needed'+ else:+ return 'Low to moderate risk'++ def _assess_instability_probability(self, data: Dict[str, Any]) -> str:+ """Assess probability of domestic instability"""+ governance_score = data.get('governance_index', 0.5)++ if governance_score < 0.3:+ return 'High instability risk'+ elif governance_score < 0.6:+ return 'Moderate instability risk'+ else:+ return 'Low instability risk'++ def _describe_risk_methodology(self) -> Dict[str, str]:+ """Describe geopolitical risk assessment methodology"""+ return {+ 'quantitative_indicators': 'Economic data, governance indices, conflict databases',+ 'qualitative_assessment': 'Expert analysis, scenario planning, historical analogies',+ 'early_warning_systems': 'Real-time monitoring of key indicators',+ 'scenario_analysis': 'Multiple future scenarios with probability weights',+ 'stress_testing': 'Impact assessment under extreme scenarios'+ }++ def _identify_early_warning_signs(self) -> List[str]:+ """Identify early warning indicators of geopolitical stress"""+ return [+ 'Diplomatic relations: Embassy closures, ambassador recalls',+ 'Military indicators: Troop movements, exercise frequency, defense spending',+ 'Economic signals: Trade restrictions, investment controls, sanctions threats',+ 'Political rhetoric: Leadership statements, media coverage, public opinion',+ 'Market indicators: Risk premiums, capital flows, currency movements'+ ]++ def _recommend_risk_mitigation(self) -> List[str]:+ """Recommend geopolitical risk mitigation strategies"""+ return [+ 'Diversification: Geographic and supply chain diversification',+ 'Scenario planning: Regular stress testing and contingency planning',+ 'Political risk insurance: Coverage for expropriation and conflict',+ 'Local partnerships: Joint ventures and local content requirements',+ 'Flexible operations: Ability to quickly adjust to changing conditions'+ ]++ def _compare_geopolitical_tools(self) -> Dict[str, str]:+ """Compare effectiveness of different geopolitical tools"""+ return {+ 'economic_tools': 'High immediate impact but may create long-term costs',+ 'diplomatic_tools': 'Low immediate impact but sustainable and relationship-preserving',+ 'military_tools': 'High coercive power but risks escalation and high costs',+ 'optimal_strategy': 'Combination of tools tailored to specific objectives and constraints'+ }++ def _analyze_sector_impacts(self, data: Dict[str, Any]) -> Dict[str, str]:+ """Analyze sectoral impacts of geopolitical risk"""+ return {+ 'defense_aerospace': 'Generally benefits from increased defense spending',+ 'energy': 'Mixed impact depending on supply chain exposure',+ 'technology': 'Vulnerable to export controls and technology restrictions',+ 'financials': 'Exposed to sanctions and capital flow restrictions',+ 'materials': 'Supply chain disruptions and commodity price volatility',+ 'consumer_discretionary': 'Reduced confidence affects spending patterns'+ }++ def _assess_geographic_impacts(self, data: Dict[str, Any]) -> Dict[str, str]:+ """Assess geographic variation in geopolitical impacts"""+ return {+ 'developed_markets': 'Relative safety but not immune to global shocks',+ 'emerging_markets': 'Higher vulnerability to capital flow reversals',+ 'frontier_markets': 'Extreme sensitivity to risk sentiment changes',+ 'regional_variation': 'Proximity to conflict zones increases impact',+ 'economic_integration': 'Highly integrated economies more affected'+ }++ def _recommend_investment_strategies(self, data: Dict[str, Any]) -> List[str]:+ """Recommend investment strategies for geopolitical risk environment"""+ return [+ 'Tactical allocation: Adjust portfolio weights based on risk assessment',+ 'Safe haven assets: Maintain allocation to defensive assets',+ 'Sector rotation: Favor sectors that benefit from geopolitical trends',+ 'Currency hedging: Protect against adverse currency movements',+ 'Volatility management: Use derivatives to manage downside risk',+ 'ESG integration: Consider governance and sustainability factors'+ ]++ def _develop_monitoring_framework(self) -> Dict[str, List[str]]:+ """Develop framework for monitoring geopolitical risks"""+ return {+ 'daily_monitoring': ['News flow', 'Market reactions', 'Policy statements'],+ 'weekly_assessment': ['Economic data', 'Diplomatic developments', 'Military activities'],+ 'monthly_review': ['Risk indicator updates', 'Scenario probability updates', 'Portfolio adjustments'],+ 'quarterly_analysis': ['Comprehensive risk assessment', 'Strategy review', 'Stress testing'],+ 'annual_planning': ['Long-term scenario development', 'Strategic asset allocation',+ 'Risk budget allocation']+ }++ def calculate(self, analysis_type: str = 'risk_assessment', **kwargs) -> Dict[str, Any]:+ """Main geopolitical analysis dispatcher"""+ analyses = {+ 'framework': self.analyze_geopolitics_framework,+ 'globalization': self.analyze_geopolitics_globalization,+ 'organizations': self.analyze_international_organizations,+ 'risk_assessment': lambda: self.assess_geopolitical_risk(kwargs.get('risk_data', {})),+ 'tools': self.analyze_geopolitical_tools,+ 'investment_implications': lambda: self.assess_investment_implications(kwargs.get('geopolitical_data', {}))+ }++ if analysis_type not in analyses:+ raise ValidationError(f"Unknown analysis type: {analysis_type}")++ result = analyses[analysis_type]()+ result['metadata'] = self.get_metadata()+ return result+++class TradingBlocAnalyzer(EconomicsBase):+ """Specialized analysis of trading blocs and economic integration"""++ def analyze_bloc_performance(self, bloc_data: Dict[str, Any]) -> Dict[str, Any]:+ """Analyze performance and effectiveness of trading blocs"""+ return {+ 'trade_creation_measurement': {+ 'intra_bloc_trade_growth': self._calculate_intra_bloc_growth(bloc_data),+ 'trade_intensity_index': self._calculate_trade_intensity(bloc_data),+ 'revealed_comparative_advantage': 'Analysis of changing trade patterns',+ 'welfare_impact_estimate': self._estimate_welfare_impact(bloc_data)+ },+ 'integration_depth_assessment': {+ 'tariff_elimination': bloc_data.get('tariff_elimination_percent', 'N/A'),+ 'non_tariff_barriers': bloc_data.get('ntb_reduction_score', 'N/A'),+ 'services_liberalization': bloc_data.get('services_openness_index', 'N/A'),+ 'factor_mobility': bloc_data.get('factor_mobility_score', 'N/A'),+ 'policy_coordination': bloc_data.get('policy_coordination_index', 'N/A')+ },+ 'economic_convergence': {+ 'income_convergence': 'Analysis of per capita income gaps',+ 'inflation_convergence': 'Monetary policy coordination effects',+ 'business_cycle_synchronization': 'Economic cycle alignment assessment',+ 'structural_convergence': 'Industry structure and productivity alignment'+ },+ 'challenges_and_obstacles': self._identify_integration_challenges(bloc_data),+ 'success_factors': self._assess_integration_success_factors(bloc_data)+ }++ def _calculate_intra_bloc_growth(self, data: Dict[str, Any]) -> str:+ """Calculate intra-bloc trade growth"""+ baseline_trade = self.to_decimal(data.get('baseline_intra_trade', 100))+ current_trade = self.to_decimal(data.get('current_intra_trade', 120))++ growth_rate = ((current_trade - baseline_trade) / baseline_trade) * self.to_decimal(100)+ return f"Intra-bloc trade grew by {growth_rate:.1f}% since formation"++ def _calculate_trade_intensity(self, data: Dict[str, Any]) -> str:+ """Calculate trade intensity index"""+ return "Trade intensity index measures whether bloc members trade more with each other than expected"++ def _estimate_welfare_impact(self, data: Dict[str, Any]) -> str:+ """Estimate welfare impact of trading bloc"""+ trade_creation = data.get('trade_creation_estimate', 'positive')+ trade_diversion = data.get('trade_diversion_estimate', 'moderate')++ if trade_creation == 'positive' and trade_diversion == 'low':+ return 'Net positive welfare impact'+ elif trade_creation == 'positive' and trade_diversion == 'moderate':+ return 'Likely positive welfare impact'+ else:+ return 'Mixed welfare impact, requires detailed analysis'++ def _identify_integration_challenges(self, data: Dict[str, Any]) -> List[str]:+ """Identify challenges to deeper integration"""+ return [+ 'Asymmetric development levels among members',+ 'Different regulatory frameworks and standards',+ 'Political sovereignty concerns',+ 'Unequal distribution of integration benefits',+ 'External pressure from non-member countries',+ 'Coordination costs and administrative burden'+ ]++ def _assess_integration_success_factors(self, data: Dict[str, Any]) -> Dict[str, str]:+ """Assess factors contributing to integration success"""+ return {+ 'political_commitment': 'Strong leadership commitment to integration goals',+ 'institutional_framework': 'Effective governance and dispute resolution mechanisms',+ 'economic_complementarity': 'Complementary rather than competing economic structures',+ 'adjustment_mechanisms': 'Policies to help losers from integration',+ 'external_support': 'Technical and financial assistance for integration process'+ }++ def calculate(self, **kwargs) -> Dict[str, Any]:+ """Calculate trading bloc analysis"""+ result = self.analyze_bloc_performance(kwargs.get('bloc_data', {}))+ result['metadata'] = self.get_metadata()+ return result\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/base_models.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/base_models.pynew file mode 100644index 000000000..0e827ab72--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/base_models.py@@ -0,0 +1,380 @@+"""+Equity Investment Base Models Module+====================================++Abstract base classes and common interfaces for equity investment analytics.+Provides foundational models for equity valuation, fundamental analysis, and+research methodologies compliant with CFA Institute standards for equity+analysis and portfolio management across all market segments and asset classes.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Financial statements (income statement, balance sheet, cash flow)+ - Market data and price series with historical performance+ - Company fundamentals and operational metrics+ - Industry and sector benchmark data+ - Economic indicators and market conditions++OUTPUT:+ - Standardized model interfaces and abstract classes+ - Equity valuation model frameworks+ - Fundamental analysis template structures+ - Research methodology guidelines+ - Portfolio analytics base implementations++PARAMETERS:+ - valuation_method: Primary valuation approach (default: 'DCF')+ - discount_rate_method: Discount rate calculation method (default: 'WACC')+ - growth_assumption: Long-term growth rate assumption (default: 0.025)+ - terminal_multiple: Terminal value multiple (default: 15.0)+ - currency_reporting: Reporting currency (default: 'USD')+ - fiscal_year_end: Company fiscal year end (default: '12-31')+"""++from abc import ABC, abstractmethod+from typing import Dict, Any, Optional, List, Union+from dataclasses import dataclass+from enum import Enum+import pandas as pd+import numpy as np+from datetime import datetime+++class ValuationMethod(Enum):+ """Enumeration of available valuation methods"""+ DDM_GORDON = "dividend_discount_gordon"+ DDM_TWO_STAGE = "dividend_discount_two_stage"+ DDM_THREE_STAGE = "dividend_discount_three_stage"+ DDM_H_MODEL = "dividend_discount_h_model"+ DCF_FCFF = "dcf_free_cash_flow_firm"+ DCF_FCFE = "dcf_free_cash_flow_equity"+ MULTIPLES_PE = "price_earnings_multiple"+ MULTIPLES_PB = "price_book_multiple"+ MULTIPLES_PS = "price_sales_multiple"+ MULTIPLES_EV_EBITDA = "enterprise_value_ebitda"+ RESIDUAL_INCOME = "residual_income_model"+ PRIVATE_INCOME = "private_income_approach"+ PRIVATE_MARKET = "private_market_approach"+ PRIVATE_ASSET = "private_asset_approach"+++class MarketEfficiencyForm(Enum):+ """Market efficiency forms as per CFA curriculum"""+ WEAK = "weak_form"+ SEMI_STRONG = "semi_strong_form"+ STRONG = "strong_form"+++class SecurityType(Enum):+ """Types of securities for analysis"""+ COMMON_STOCK = "common_stock"+ PREFERRED_STOCK = "preferred_stock"+ CORPORATE_BOND = "corporate_bond"+ GOVERNMENT_BOND = "government_bond"+ OPTION = "option"+ FUTURE = "future"+ COMMODITY = "commodity"+ CURRENCY = "currency"+++@dataclass+class CompanyData:+ """Standard company data structure"""+ symbol: str+ name: str+ sector: str+ industry: str+ market_cap: float+ shares_outstanding: float+ current_price: float+ financial_data: Dict[str, Any]+ market_data: Dict[str, Any]+ last_updated: datetime+++@dataclass+class ValuationResult:+ """Standard valuation result structure"""+ method: ValuationMethod+ intrinsic_value: float+ current_price: float+ recommendation: str # "BUY", "HOLD", "SELL"+ upside_downside: float+ confidence_level: str # "HIGH", "MEDIUM", "LOW"+ assumptions: Dict[str, Any]+ sensitivity_analysis: Optional[Dict[str, float]] = None+ calculation_details: Optional[Dict[str, Any]] = None+++@dataclass+class MarketData:+ """Market data structure"""+ risk_free_rate: float+ market_return: float+ beta: float+ dividend_yield: float+ growth_rate: float+ required_return: float+++class BaseAnalyticalModel(ABC):+ """Abstract base class for all analytical models"""++ def __init__(self, name: str, description: str):+ self.name = name+ self.description = description+ self.last_calculation = None+ self.assumptions = {}++ @abstractmethod+ def validate_inputs(self, **kwargs) -> bool:+ """Validate input parameters for the model"""+ pass++ @abstractmethod+ def calculate(self, **kwargs) -> ValuationResult:+ """Perform the main calculation"""+ pass++ def get_assumptions(self) -> Dict[str, Any]:+ """Return current model assumptions"""+ return self.assumptions.copy()++ def set_assumptions(self, **kwargs):+ """Set model assumptions"""+ self.assumptions.update(kwargs)+++class BaseValuationModel(BaseAnalyticalModel):+ """Base class for equity valuation models"""++ def __init__(self, name: str, description: str):+ super().__init__(name, description)+ self.valuation_method = None++ @abstractmethod+ def calculate_intrinsic_value(self, company_data: CompanyData, market_data: MarketData) -> float:+ """Calculate intrinsic value of the security"""+ pass++ def generate_recommendation(self, intrinsic_value: float, current_price: float) -> str:+ """Generate buy/hold/sell recommendation"""+ upside = (intrinsic_value - current_price) / current_price++ if upside > 0.15:+ return "BUY"+ elif upside < -0.15:+ return "SELL"+ else:+ return "HOLD"++ def calculate_upside_downside(self, intrinsic_value: float, current_price: float) -> float:+ """Calculate percentage upside/downside"""+ return (intrinsic_value - current_price) / current_price+++class BaseMarketAnalysisModel(BaseAnalyticalModel):+ """Base class for market analysis models"""++ def __init__(self, name: str, description: str):+ super().__init__(name, description)++ @abstractmethod+ def analyze_market_data(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze market data and return insights"""+ pass+++class BaseCompanyAnalysisModel(BaseAnalyticalModel):+ """Base class for company analysis models"""++ def __init__(self, name: str, description: str):+ super().__init__(name, description)++ @abstractmethod+ def analyze_company(self, company_data: CompanyData) -> Dict[str, Any]:+ """Analyze company fundamentals"""+ pass+++class DataProvider(ABC):+ """Abstract base class for data providers"""++ @abstractmethod+ def get_company_data(self, symbol: str) -> CompanyData:+ """Retrieve company data"""+ pass++ @abstractmethod+ def get_market_data(self, symbol: str) -> MarketData:+ """Retrieve market data"""+ pass++ @abstractmethod+ def get_financial_statements(self, symbol: str, period: str = "annual") -> Dict[str, pd.DataFrame]:+ """Retrieve financial statements"""+ pass++ @abstractmethod+ def get_price_data(self, symbol: str, start_date: str, end_date: str) -> pd.DataFrame:+ """Retrieve historical price data"""+ pass+++class CalculationEngine:+ """Core calculation engine with common financial formulas"""++ @staticmethod+ def present_value(future_value: float, rate: float, periods: int) -> float:+ """Calculate present value"""+ return future_value / ((1 + rate) ** periods)++ @staticmethod+ def future_value(present_value: float, rate: float, periods: int) -> float:+ """Calculate future value"""+ return present_value * ((1 + rate) ** periods)++ @staticmethod+ def npv(cash_flows: List[float], discount_rate: float) -> float:+ """Calculate Net Present Value"""+ npv = 0+ for i, cf in enumerate(cash_flows):+ npv += cf / ((1 + discount_rate) ** i)+ return npv++ @staticmethod+ def irr(cash_flows: List[float], guess: float = 0.1) -> float:+ """Calculate Internal Rate of Return using Newton-Raphson method"""+ rate = guess+ tolerance = 1e-6+ max_iterations = 100++ for _ in range(max_iterations):+ npv = sum(cf / ((1 + rate) ** i) for i, cf in enumerate(cash_flows))+ npv_derivative = sum(-i * cf / ((1 + rate) ** (i + 1)) for i, cf in enumerate(cash_flows))++ if abs(npv) < tolerance:+ return rate++ rate = rate - npv / npv_derivative++ return rate++ @staticmethod+ def capm_required_return(risk_free_rate: float, beta: float, market_return: float) -> float:+ """Calculate required return using CAPM"""+ return risk_free_rate + beta * (market_return - risk_free_rate)++ @staticmethod+ def gordon_growth_model(dividend: float, growth_rate: float, required_return: float) -> float:+ """Calculate value using Gordon Growth Model"""+ if required_return <= growth_rate:+ raise ValueError("Required return must be greater than growth rate")+ return dividend * (1 + growth_rate) / (required_return - growth_rate)++ @staticmethod+ def sustainable_growth_rate(roe: float, payout_ratio: float) -> float:+ """Calculate sustainable growth rate"""+ retention_ratio = 1 - payout_ratio+ return roe * retention_ratio++ @staticmethod+ def dupont_roe(net_margin: float, asset_turnover: float, equity_multiplier: float) -> float:+ """Calculate ROE using DuPont analysis"""+ return net_margin * asset_turnover * equity_multiplier++ @staticmethod+ def pe_ratio_from_fundamentals(payout_ratio: float, required_return: float, growth_rate: float) -> float:+ """Calculate justified P/E ratio from fundamentals"""+ if required_return <= growth_rate:+ raise ValueError("Required return must be greater than growth rate")+ return payout_ratio * (1 + growth_rate) / (required_return - growth_rate)++ @staticmethod+ def free_cash_flow_to_equity(net_income: float, depreciation: float, capex: float,+ working_capital_change: float, net_borrowing: float) -> float:+ """Calculate Free Cash Flow to Equity"""+ return net_income + depreciation - capex - working_capital_change + net_borrowing++ @staticmethod+ def free_cash_flow_to_firm(ebit: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float) -> float:+ """Calculate Free Cash Flow to Firm"""+ nopat = ebit * (1 - tax_rate)+ return nopat + depreciation - capex - working_capital_change++ @staticmethod+ def residual_income(net_income: float, beginning_book_value: float, required_return: float) -> float:+ """Calculate Residual Income"""+ equity_charge = beginning_book_value * required_return+ return net_income - equity_charge++ @staticmethod+ def economic_value_added(nopat: float, invested_capital: float, wacc: float) -> float:+ """Calculate Economic Value Added (EVA)"""+ capital_charge = invested_capital * wacc+ return nopat - capital_charge+++class ModelValidator:+ """Validation utilities for model inputs"""++ @staticmethod+ def validate_positive_number(value: Union[int, float], name: str) -> bool:+ """Validate that a number is positive"""+ if not isinstance(value, (int, float)) or value <= 0:+ raise ValueError(f"{name} must be a positive number")+ return True++ @staticmethod+ def validate_percentage(value: float, name: str, allow_negative: bool = False) -> bool:+ """Validate percentage values"""+ if not isinstance(value, (int, float)):+ raise ValueError(f"{name} must be a number")+ if not allow_negative and value < 0:+ raise ValueError(f"{name} cannot be negative")+ if value > 1:+ raise ValueError(f"{name} appears to be in percentage form, please use decimal (e.g., 0.05 for 5%)")+ return True++ @staticmethod+ def validate_growth_vs_required_return(growth_rate: float, required_return: float) -> bool:+ """Validate that growth rate is less than required return for DDM models"""+ if growth_rate >= required_return:+ raise ValueError("Growth rate must be less than required return for stable growth models")+ return True++ @staticmethod+ def validate_company_data(company_data: CompanyData) -> bool:+ """Validate company data structure"""+ required_fields = ['symbol', 'current_price', 'shares_outstanding']+ for field in required_fields:+ if not hasattr(company_data, field) or getattr(company_data, field) is None:+ raise ValueError(f"Company data missing required field: {field}")+ return True+++# Exception classes for better error handling+class FinceptAnalyticsError(Exception):+ """Base exception for analytics module"""+ pass+++class DataProviderError(FinceptAnalyticsError):+ """Exception for data provider issues"""+ pass+++class ValidationError(FinceptAnalyticsError):+ """Exception for input validation failures"""+ pass+++class CalculationError(FinceptAnalyticsError):+ """Exception for calculation failures"""+ pass+++class ModelError(FinceptAnalyticsError):+ """Exception for model-specific issues"""+ pass\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/data_providers.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/data_providers.pynew file mode 100644index 000000000..d3c6054c1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/data_providers.py@@ -0,0 +1,496 @@++Equity Investment Data Providers Module+======================================++Data provider implementations and interfaces++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import pandas as pd+import numpy as np+import yfinance as yf+import requests+import json+import csv+from typing import Dict, Any, Optional, List, Union+from datetime import datetime, timedelta+from abc import ABC, abstractmethod+import warnings++warnings.filterwarnings('ignore')++from .base_models import (+ DataProvider, CompanyData, MarketData, SecurityType,+ DataProviderError, FinceptAnalyticsError+)+++class YahooFinanceProvider(DataProvider):+ """Yahoo Finance data provider implementation"""++ def __init__(self):+ self.name = "Yahoo Finance"+ self.base_url = "https://finance.yahoo.com"++ def get_company_data(self, symbol: str) -> CompanyData:+ """Retrieve comprehensive company data from Yahoo Finance"""+ try:+ ticker = yf.Ticker(symbol)+ info = ticker.info++ # Get current price and basic info+ current_price = info.get('currentPrice') or info.get('regularMarketPrice', 0)+ shares_outstanding = info.get('sharesOutstanding', 0)+ market_cap = info.get('marketCap', current_price * shares_outstanding)++ # Financial data extraction+ financial_data = {+ 'revenue': info.get('totalRevenue', 0),+ 'net_income': info.get('netIncomeToCommon', 0),+ 'total_assets': info.get('totalAssets', 0),+ 'total_debt': info.get('totalDebt', 0),+ 'book_value': info.get('bookValue', 0),+ 'earnings_per_share': info.get('trailingEps', 0),+ 'dividend_per_share': info.get('dividendRate', 0),+ 'roe': info.get('returnOnEquity', 0),+ 'roa': info.get('returnOnAssets', 0),+ 'profit_margin': info.get('profitMargins', 0),+ 'debt_to_equity': info.get('debtToEquity', 0),+ 'current_ratio': info.get('currentRatio', 0),+ 'quick_ratio': info.get('quickRatio', 0),+ 'ebitda': info.get('ebitda', 0),+ 'free_cash_flow': info.get('freeCashflow', 0),+ 'operating_cash_flow': info.get('operatingCashflow', 0)+ }++ # Market data extraction+ market_data = {+ 'beta': info.get('beta', 1.0),+ 'pe_ratio': info.get('trailingPE', 0),+ 'forward_pe': info.get('forwardPE', 0),+ 'pb_ratio': info.get('priceToBook', 0),+ 'ps_ratio': info.get('priceToSalesTrailing12Months', 0),+ 'peg_ratio': info.get('pegRatio', 0),+ 'dividend_yield': info.get('dividendYield', 0),+ 'revenue_growth': info.get('revenueGrowth', 0),+ 'earnings_growth': info.get('earningsGrowth', 0),+ '52_week_high': info.get('fiftyTwoWeekHigh', 0),+ '52_week_low': info.get('fiftyTwoWeekLow', 0),+ 'average_volume': info.get('averageVolume', 0),+ 'float_shares': info.get('floatShares', shares_outstanding)+ }++ return CompanyData(+ symbol=symbol.upper(),+ name=info.get('longName', symbol),+ sector=info.get('sector', 'Unknown'),+ industry=info.get('industry', 'Unknown'),+ market_cap=market_cap,+ shares_outstanding=shares_outstanding,+ current_price=current_price,+ financial_data=financial_data,+ market_data=market_data,+ last_updated=datetime.now()+ )++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve company data for {symbol}: {str(e)}")++ def get_market_data(self, symbol: str) -> MarketData:+ """Retrieve market-specific data for valuation models"""+ try:+ ticker = yf.Ticker(symbol)+ info = ticker.info++ # Get risk-free rate (10-year Treasury)+ treasury = yf.Ticker("^TNX")+ risk_free_rate = treasury.history(period="1d")['Close'].iloc[-1] / 100++ # Get market return (S&P 500 annual return)+ sp500 = yf.Ticker("^GSPC")+ sp500_data = sp500.history(period="1y")+ market_return = (sp500_data['Close'].iloc[-1] / sp500_data['Close'].iloc[0] - 1)++ return MarketData(+ risk_free_rate=risk_free_rate,+ market_return=market_return,+ beta=info.get('beta', 1.0),+ dividend_yield=info.get('dividendYield', 0),+ growth_rate=info.get('earningsGrowth', 0.03), # Default 3% if not available+ required_return=risk_free_rate + info.get('beta', 1.0) * (market_return - risk_free_rate)+ )++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve market data for {symbol}: {str(e)}")++ def get_financial_statements(self, symbol: str, period: str = "annual") -> Dict[str, pd.DataFrame]:+ """Retrieve financial statements"""+ try:+ ticker = yf.Ticker(symbol)++ if period == "annual":+ income_stmt = ticker.financials+ balance_sheet = ticker.balance_sheet+ cash_flow = ticker.cashflow+ else:+ income_stmt = ticker.quarterly_financials+ balance_sheet = ticker.quarterly_balance_sheet+ cash_flow = ticker.quarterly_cashflow++ return {+ 'income_statement': income_stmt,+ 'balance_sheet': balance_sheet,+ 'cash_flow_statement': cash_flow+ }++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve financial statements for {symbol}: {str(e)}")++ def get_price_data(self, symbol: str, start_date: str, end_date: str) -> pd.DataFrame:+ """Retrieve historical price data"""+ try:+ ticker = yf.Ticker(symbol)+ return ticker.history(start=start_date, end=end_date)+ except Exception as e:+ raise DataProviderError(f"Failed to retrieve price data for {symbol}: {str(e)}")+++class AlphaVantageProvider(DataProvider):+ """Alpha Vantage data provider implementation"""++ def __init__(self, api_key: str):+ self.name = "Alpha Vantage"+ self.api_key = api_key+ self.base_url = "https://www.alphavantage.co/query"++ def _make_request(self, params: Dict[str, str]) -> Dict[str, Any]:+ """Make API request to Alpha Vantage"""+ params['apikey'] = self.api_key+ response = requests.get(self.base_url, params=params)+ response.raise_for_status()+ return response.json()++ def get_company_data(self, symbol: str) -> CompanyData:+ """Retrieve company data from Alpha Vantage"""+ try:+ # Get company overview+ overview_params = {+ 'function': 'OVERVIEW',+ 'symbol': symbol+ }+ overview = self._make_request(overview_params)++ # Get quote data+ quote_params = {+ 'function': 'GLOBAL_QUOTE',+ 'symbol': symbol+ }+ quote_data = self._make_request(quote_params)+ quote = quote_data.get('Global Quote', {})++ current_price = float(quote.get('05. price', 0))+ shares_outstanding = float(overview.get('SharesOutstanding', 0))++ financial_data = {+ 'revenue': float(overview.get('RevenueTTM', 0)),+ 'net_income': float(overview.get('ProfitMargin', 0)) * float(overview.get('RevenueTTM', 0)),+ 'total_assets': 0, # Not available in overview+ 'book_value': float(overview.get('BookValue', 0)),+ 'earnings_per_share': float(overview.get('EPS', 0)),+ 'dividend_per_share': float(overview.get('DividendPerShare', 0)),+ 'roe': float(overview.get('ReturnOnEquityTTM', 0)),+ 'profit_margin': float(overview.get('ProfitMargin', 0)),+ 'ebitda': float(overview.get('EBITDA', 0))+ }++ market_data = {+ 'beta': float(overview.get('Beta', 1.0)),+ 'pe_ratio': float(overview.get('PERatio', 0)),+ 'pb_ratio': float(overview.get('PriceToBookRatio', 0)),+ 'peg_ratio': float(overview.get('PEGRatio', 0)),+ 'dividend_yield': float(overview.get('DividendYield', 0)),+ '52_week_high': float(overview.get('52WeekHigh', 0)),+ '52_week_low': float(overview.get('52WeekLow', 0))+ }++ return CompanyData(+ symbol=symbol.upper(),+ name=overview.get('Name', symbol),+ sector=overview.get('Sector', 'Unknown'),+ industry=overview.get('Industry', 'Unknown'),+ market_cap=float(overview.get('MarketCapitalization', 0)),+ shares_outstanding=shares_outstanding,+ current_price=current_price,+ financial_data=financial_data,+ market_data=market_data,+ last_updated=datetime.now()+ )++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve company data for {symbol}: {str(e)}")++ def get_market_data(self, symbol: str) -> MarketData:+ """Retrieve market data from Alpha Vantage"""+ # Implementation similar to Yahoo Finance but using Alpha Vantage API+ # For brevity, using simplified version+ try:+ overview_params = {+ 'function': 'OVERVIEW',+ 'symbol': symbol+ }+ overview = self._make_request(overview_params)++ return MarketData(+ risk_free_rate=0.05, # Default values - would need Treasury API+ market_return=0.10,+ beta=float(overview.get('Beta', 1.0)),+ dividend_yield=float(overview.get('DividendYield', 0)),+ growth_rate=0.03,+ required_return=0.08+ )+ except Exception as e:+ raise DataProviderError(f"Failed to retrieve market data for {symbol}: {str(e)}")++ def get_financial_statements(self, symbol: str, period: str = "annual") -> Dict[str, pd.DataFrame]:+ """Retrieve financial statements from Alpha Vantage"""+ try:+ statements = {}++ # Income Statement+ income_params = {+ 'function': 'INCOME_STATEMENT',+ 'symbol': symbol+ }+ income_data = self._make_request(income_params)++ if period == "annual":+ statements['income_statement'] = pd.DataFrame(income_data.get('annualReports', []))+ else:+ statements['income_statement'] = pd.DataFrame(income_data.get('quarterlyReports', []))++ # Balance Sheet+ balance_params = {+ 'function': 'BALANCE_SHEET',+ 'symbol': symbol+ }+ balance_data = self._make_request(balance_params)++ if period == "annual":+ statements['balance_sheet'] = pd.DataFrame(balance_data.get('annualReports', []))+ else:+ statements['balance_sheet'] = pd.DataFrame(balance_data.get('quarterlyReports', []))++ # Cash Flow+ cashflow_params = {+ 'function': 'CASH_FLOW',+ 'symbol': symbol+ }+ cashflow_data = self._make_request(cashflow_params)++ if period == "annual":+ statements['cash_flow_statement'] = pd.DataFrame(cashflow_data.get('annualReports', []))+ else:+ statements['cash_flow_statement'] = pd.DataFrame(cashflow_data.get('quarterlyReports', []))++ return statements++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve financial statements for {symbol}: {str(e)}")++ def get_price_data(self, symbol: str, start_date: str, end_date: str) -> pd.DataFrame:+ """Retrieve historical price data from Alpha Vantage"""+ try:+ params = {+ 'function': 'TIME_SERIES_DAILY_ADJUSTED',+ 'symbol': symbol,+ 'outputsize': 'full'+ }+ data = self._make_request(params)+ time_series = data.get('Time Series (Daily)', {})++ df = pd.DataFrame.from_dict(time_series, orient='index')+ df.index = pd.to_datetime(df.index)+ df = df.sort_index()++ # Rename columns to match yfinance format+ df.columns = ['Open', 'High', 'Low', 'Close', 'Adj Close', 'Volume', 'Dividend', 'Split']+ df = df.astype(float)++ # Filter by date range+ mask = (df.index >= start_date) & (df.index <= end_date)+ return df.loc[mask]++ except Exception as e:+ raise DataProviderError(f"Failed to retrieve price data for {symbol}: {str(e)}")+++class ManualDataProvider(DataProvider):+ """Manual data input provider for user-supplied data"""++ def __init__(self):+ self.name = "Manual Input"+ self.data_cache = {}++ def add_company_data(self, company_data: CompanyData):+ """Add manually input company data"""+ self.data_cache[company_data.symbol] = company_data++ def load_from_csv(self, file_path: str, symbol: str):+ """Load company data from CSV file"""+ try:+ df = pd.read_csv(file_path)++ # Convert CSV data to CompanyData format+ # Assumes specific CSV structure - can be customized+ financial_data = df.to_dict('records')[0] if not df.empty else {}++ company_data = CompanyData(+ symbol=symbol.upper(),+ name=financial_data.get('company_name', symbol),+ sector=financial_data.get('sector', 'Unknown'),+ industry=financial_data.get('industry', 'Unknown'),+ market_cap=float(financial_data.get('market_cap', 0)),+ shares_outstanding=float(financial_data.get('shares_outstanding', 0)),+ current_price=float(financial_data.get('current_price', 0)),+ financial_data=financial_data,+ market_data={},+ last_updated=datetime.now()+ )++ self.add_company_data(company_data)++ except Exception as e:+ raise DataProviderError(f"Failed to load CSV data: {str(e)}")++ def get_company_data(self, symbol: str) -> CompanyData:+ """Retrieve manually input company data"""+ if symbol.upper() not in self.data_cache:+ raise DataProviderError(f"No manual data available for {symbol}")+ return self.data_cache[symbol.upper()]++ def get_market_data(self, symbol: str) -> MarketData:+ """Retrieve market data - requires manual input"""+ # Return default market data or raise error for manual input+ return MarketData(+ risk_free_rate=0.05,+ market_return=0.10,+ beta=1.0,+ dividend_yield=0.02,+ growth_rate=0.03,+ required_return=0.08+ )++ def get_financial_statements(self, symbol: str, period: str = "annual") -> Dict[str, pd.DataFrame]:+ """Manual financial statements not implemented"""+ raise DataProviderError("Manual financial statements input not implemented")++ def get_price_data(self, symbol: str, start_date: str, end_date: str) -> pd.DataFrame:+ """Manual price data not implemented"""+ raise DataProviderError("Manual price data input not implemented")+++class DataProviderFactory:+ """Factory class for managing multiple data providers with fallback"""++ def __init__(self):+ self.providers = {}+ self.primary_provider = None+ self.fallback_providers = []++ def register_provider(self, name: str, provider: DataProvider, is_primary: bool = False):+ """Register a data provider"""+ self.providers[name] = provider+ if is_primary:+ self.primary_provider = name+ else:+ self.fallback_providers.append(name)++ def get_provider(self, name: str) -> DataProvider:+ """Get specific provider by name"""+ if name not in self.providers:+ raise DataProviderError(f"Provider {name} not registered")+ return self.providers[name]++ def get_company_data(self, symbol: str, provider_name: Optional[str] = None) -> CompanyData:+ """Get company data with automatic fallback"""+ providers_to_try = [provider_name] if provider_name else [self.primary_provider] + self.fallback_providers++ for provider_name in providers_to_try:+ if provider_name and provider_name in self.providers:+ try:+ return self.providers[provider_name].get_company_data(symbol)+ except Exception as e:+ print(f"Provider {provider_name} failed: {str(e)}")+ continue++ raise DataProviderError(f"All data providers failed for symbol {symbol}")++ def get_market_data(self, symbol: str, provider_name: Optional[str] = None) -> MarketData:+ """Get market data with automatic fallback"""+ providers_to_try = [provider_name] if provider_name else [self.primary_provider] + self.fallback_providers++ for provider_name in providers_to_try:+ if provider_name and provider_name in self.providers:+ try:+ return self.providers[provider_name].get_market_data(symbol)+ except Exception as e:+ print(f"Provider {provider_name} failed: {str(e)}")+ continue++ raise DataProviderError(f"All data providers failed for market data {symbol}")+++# Global data provider factory instance+data_factory = DataProviderFactory()+++def setup_default_providers(alpha_vantage_key: Optional[str] = None):+ """Setup default data providers"""++ # Register Yahoo Finance as primary+ yahoo_provider = YahooFinanceProvider()+ data_factory.register_provider("yahoo", yahoo_provider, is_primary=True)++ # Register Alpha Vantage if API key provided+ if alpha_vantage_key:+ av_provider = AlphaVantageProvider(alpha_vantage_key)+ data_factory.register_provider("alphavantage", av_provider)++ # Register manual provider+ manual_provider = ManualDataProvider()+ data_factory.register_provider("manual", manual_provider)+++def get_company_data(symbol: str, provider: Optional[str] = None) -> CompanyData:+ """Convenience function to get company data"""+ return data_factory.get_company_data(symbol, provider)+++def get_market_data(symbol: str, provider: Optional[str] = None) -> MarketData:+ """Convenience function to get market data"""+ return data_factory.get_market_data(symbol, provider)+++# Initialize with default providers+setup_default_providers()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/validators.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/validators.pynew file mode 100644index 000000000..d7bb57440--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/base/validators.py@@ -0,0 +1,522 @@++Equity Investment Validators Module+======================================++Data validation and quality checks++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import pandas as pd+import numpy as np+from typing import Dict, Any, List, Union, Optional+from datetime import datetime+import re++from .base_models import (+ CompanyData, MarketData, ValidationError,+ ValuationMethod, SecurityType+)+++class CFAValidator:+ """Comprehensive validator based on CFA curriculum standards"""++ @staticmethod+ def validate_financial_ratios(ratios: Dict[str, float]) -> Dict[str, List[str]]:+ """Validate financial ratios and return warnings/errors"""+ warnings = []+ errors = []++ # P/E ratio validation+ if 'pe_ratio' in ratios:+ pe = ratios['pe_ratio']+ if pe < 0:+ errors.append("P/E ratio cannot be negative (company has negative earnings)")+ elif pe > 100:+ warnings.append(f"P/E ratio of {pe:.2f} is unusually high - verify earnings quality")++ # P/B ratio validation+ if 'pb_ratio' in ratios:+ pb = ratios['pb_ratio']+ if pb < 0:+ errors.append("P/B ratio cannot be negative (negative book value)")+ elif pb > 10:+ warnings.append(f"P/B ratio of {pb:.2f} is very high - company may be overvalued or asset-light")++ # ROE validation+ if 'roe' in ratios:+ roe = ratios['roe']+ if roe < -0.5:+ warnings.append(f"ROE of {roe:.2%} indicates significant losses")+ elif roe > 0.5:+ warnings.append(f"ROE of {roe:.2%} is exceptionally high - verify sustainability")++ # Debt-to-Equity validation+ if 'debt_to_equity' in ratios:+ de = ratios['debt_to_equity']+ if de < 0:+ errors.append("Debt-to-Equity ratio cannot be negative")+ elif de > 5:+ warnings.append(f"D/E ratio of {de:.2f} indicates high leverage - assess financial risk")++ # Current ratio validation+ if 'current_ratio' in ratios:+ cr = ratios['current_ratio']+ if cr < 1:+ warnings.append(f"Current ratio of {cr:.2f} may indicate liquidity concerns")+ elif cr > 5:+ warnings.append(f"Current ratio of {cr:.2f} may indicate inefficient asset utilization")++ return {'warnings': warnings, 'errors': errors}++ @staticmethod+ def validate_growth_rates(growth_data: Dict[str, float]) -> Dict[str, List[str]]:+ """Validate growth rate assumptions"""+ warnings = []+ errors = []++ # Revenue growth validation+ if 'revenue_growth' in growth_data:+ rg = growth_data['revenue_growth']+ if rg < -0.5:+ warnings.append(f"Revenue decline of {rg:.2%} is severe - verify business viability")+ elif rg > 0.5:+ warnings.append(f"Revenue growth of {rg:.2%} is very high - assess sustainability")++ # Earnings growth validation+ if 'earnings_growth' in growth_data:+ eg = growth_data['earnings_growth']+ if eg > 1.0:+ warnings.append(f"Earnings growth of {eg:.2%} is extremely high - verify quality")++ # Long-term growth validation+ if 'long_term_growth' in growth_data:+ ltg = growth_data['long_term_growth']+ if ltg > 0.06: # 6% long-term growth is generally considered maximum sustainable+ warnings.append(f"Long-term growth of {ltg:.2%} exceeds typical economic growth limits")+ elif ltg < 0:+ warnings.append("Negative long-term growth assumptions should be carefully justified")++ return {'warnings': warnings, 'errors': errors}++ @staticmethod+ def validate_discount_rates(rates: Dict[str, float]) -> Dict[str, List[str]]:+ """Validate discount rate assumptions"""+ warnings = []+ errors = []++ # Risk-free rate validation+ if 'risk_free_rate' in rates:+ rf = rates['risk_free_rate']+ if rf < 0:+ warnings.append("Negative risk-free rate - unusual market conditions")+ elif rf > 0.15:+ warnings.append(f"Risk-free rate of {rf:.2%} is very high - verify source")++ # Required return validation+ if 'required_return' in rates:+ rr = rates['required_return']+ if rr < 0.02:+ warnings.append(f"Required return of {rr:.2%} seems too low")+ elif rr > 0.25:+ warnings.append(f"Required return of {rr:.2%} is very high - verify risk assessment")++ # WACC validation+ if 'wacc' in rates:+ wacc = rates['wacc']+ if wacc < 0.03:+ warnings.append(f"WACC of {wacc:.2%} seems low - verify calculation")+ elif wacc > 0.20:+ warnings.append(f"WACC of {wacc:.2%} is high - assess company risk")++ # Risk premium validation+ if 'risk_free_rate' in rates and 'required_return' in rates:+ risk_premium = rates['required_return'] - rates['risk_free_rate']+ if risk_premium < 0:+ errors.append("Risk premium cannot be negative")+ elif risk_premium > 0.15:+ warnings.append(f"Risk premium of {risk_premium:.2%} is very high")++ return {'warnings': warnings, 'errors': errors}+++class DDMValidator:+ """Validator for Dividend Discount Models"""++ @staticmethod+ def validate_gordon_growth_inputs(dividend: float, growth_rate: float,+ required_return: float) -> bool:+ """Validate Gordon Growth Model inputs"""+ errors = []++ if dividend <= 0:+ errors.append("Dividend must be positive for Gordon Growth Model")++ if growth_rate >= required_return:+ errors.append("Growth rate must be less than required return for Gordon Growth Model")++ if required_return <= 0:+ errors.append("Required return must be positive")++ if abs(required_return - growth_rate) < 0.01:+ errors.append("Required return and growth rate are too close - model becomes unstable")++ if errors:+ raise ValidationError("; ".join(errors))++ return True++ @staticmethod+ def validate_multistage_ddm_inputs(dividends: List[float], growth_rates: List[float],+ required_return: float, terminal_growth: float) -> bool:+ """Validate multi-stage DDM inputs"""+ errors = []++ if len(dividends) != len(growth_rates):+ errors.append("Number of dividends must match number of growth rates")++ if any(d <= 0 for d in dividends):+ errors.append("All dividends must be positive")++ if terminal_growth >= required_return:+ errors.append("Terminal growth rate must be less than required return")++ if terminal_growth > 0.06: # Conservative long-term growth limit+ errors.append("Terminal growth rate should not exceed 6% for most companies")++ for i, gr in enumerate(growth_rates):+ if gr > 0.5: # 50% growth rate warning+ errors.append(f"Growth rate of {gr:.2%} in period {i + 1} is very high")++ if errors:+ raise ValidationError("; ".join(errors))++ return True+++class DCFValidator:+ """Validator for Discounted Cash Flow Models"""++ @staticmethod+ def validate_fcf_inputs(cash_flows: List[float], discount_rate: float,+ terminal_value: Optional[float] = None) -> bool:+ """Validate Free Cash Flow inputs"""+ errors = []+ warnings = []++ if discount_rate <= 0:+ errors.append("Discount rate must be positive")++ if discount_rate > 0.25:+ warnings.append(f"Discount rate of {discount_rate:.2%} is very high")++ # Check for negative cash flows+ negative_cf_count = sum(1 for cf in cash_flows if cf < 0)+ if negative_cf_count > len(cash_flows) / 2:+ warnings.append("More than half of projected cash flows are negative")++ # Check for unrealistic growth in cash flows+ for i in range(1, len(cash_flows)):+ if cash_flows[i - 1] > 0 and cash_flows[i] > 0:+ growth = (cash_flows[i] / cash_flows[i - 1]) - 1+ if growth > 1.0: # 100% growth+ warnings.append(f"Cash flow growth of {growth:.2%} in year {i + 1} is very high")++ if terminal_value and terminal_value < 0:+ errors.append("Terminal value cannot be negative")++ if errors:+ raise ValidationError("; ".join(errors))++ if warnings:+ print("DCF Warnings:", "; ".join(warnings))++ return True++ @staticmethod+ def validate_fcff_calculation_inputs(ebit: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float) -> bool:+ """Validate FCFF calculation inputs"""+ errors = []++ if tax_rate < 0 or tax_rate > 1:+ errors.append("Tax rate must be between 0 and 1")++ if depreciation < 0:+ errors.append("Depreciation cannot be negative")++ if capex < 0:+ errors.append("Capital expenditures cannot be negative")++ # Warning for unusual values+ if tax_rate > 0.5:+ print(f"Warning: Tax rate of {tax_rate:.2%} is very high")++ if capex > abs(ebit) * 2:+ print("Warning: Capital expenditures are very high relative to EBIT")++ if errors:+ raise ValidationError("; ".join(errors))++ return True+++class MultiplesValidator:+ """Validator for Market Multiple Valuation"""++ @staticmethod+ def validate_comparable_companies(comparables: List[Dict[str, Any]],+ target_company: Dict[str, Any]) -> bool:+ """Validate comparable companies selection"""+ errors = []+ warnings = []++ if len(comparables) < 3:+ warnings.append("Fewer than 3 comparable companies - results may be unreliable")++ # Check for similar business characteristics+ target_sector = target_company.get('sector', '')+ target_size = target_company.get('market_cap', 0)++ different_sector_count = 0+ size_differences = []++ for comp in comparables:+ # Sector comparison+ if comp.get('sector', '') != target_sector:+ different_sector_count += 1++ # Size comparison+ comp_size = comp.get('market_cap', 0)+ if target_size > 0 and comp_size > 0:+ size_ratio = max(comp_size, target_size) / min(comp_size, target_size)+ size_differences.append(size_ratio)++ if different_sector_count > len(comparables) / 2:+ warnings.append("More than half of comparables are from different sectors")++ if size_differences and max(size_differences) > 10:+ warnings.append("Some comparables differ significantly in size from target company")++ if warnings:+ print("Comparables Warnings:", "; ".join(warnings))++ return True++ @staticmethod+ def validate_multiple_values(multiples: Dict[str, float]) -> bool:+ """Validate individual multiple values"""+ errors = []+ warnings = []++ for metric, value in multiples.items():+ if value < 0:+ errors.append(f"{metric} cannot be negative")++ # Specific warnings for each multiple+ if metric == 'pe_ratio' and value > 50:+ warnings.append(f"P/E ratio of {value:.2f} is very high")+ elif metric == 'pb_ratio' and value > 5:+ warnings.append(f"P/B ratio of {value:.2f} is high")+ elif metric == 'ps_ratio' and value > 10:+ warnings.append(f"P/S ratio of {value:.2f} is high")+ elif metric == 'ev_ebitda' and value > 20:+ warnings.append(f"EV/EBITDA of {value:.2f} is high")++ if errors:+ raise ValidationError("; ".join(errors))++ if warnings:+ print("Multiple Validation Warnings:", "; ".join(warnings))++ return True+++class ResidualIncomeValidator:+ """Validator for Residual Income Models"""++ @staticmethod+ def validate_ri_inputs(net_income: float, book_value: float,+ required_return: float, roe: float) -> bool:+ """Validate Residual Income model inputs"""+ errors = []+ warnings = []++ if book_value <= 0:+ errors.append("Book value must be positive for Residual Income model")++ if required_return <= 0:+ errors.append("Required return must be positive")++ if required_return > 0.3:+ warnings.append(f"Required return of {required_return:.2%} is very high")++ # Check ROE vs required return relationship+ if roe > 0 and abs(roe - required_return) < 0.01:+ warnings.append("ROE and required return are very close - residual income will be minimal")++ # Check for consistency+ calculated_roe = net_income / book_value if book_value != 0 else 0+ if abs(calculated_roe - roe) > 0.02: # 2% difference tolerance+ warnings.append("Provided ROE doesn't match calculated ROE from net income and book value")++ if errors:+ raise ValidationError("; ".join(errors))++ if warnings:+ print("Residual Income Warnings:", "; ".join(warnings))++ return True+++class CompanyDataValidator:+ """Validator for Company Data Integrity"""++ @staticmethod+ def validate_company_data(company_data: CompanyData) -> Dict[str, List[str]]:+ """Comprehensive validation of company data"""+ errors = []+ warnings = []++ # Basic data validation+ if not company_data.symbol:+ errors.append("Company symbol is required")++ if company_data.current_price <= 0:+ errors.append("Current price must be positive")++ if company_data.shares_outstanding <= 0:+ errors.append("Shares outstanding must be positive")++ # Market cap consistency check+ calculated_market_cap = company_data.current_price * company_data.shares_outstanding+ if abs(calculated_market_cap - company_data.market_cap) / company_data.market_cap > 0.1:+ warnings.append("Market cap inconsistent with price × shares outstanding")++ # Financial data validation+ financial_data = company_data.financial_data++ # Revenue validation+ revenue = financial_data.get('revenue', 0)+ if revenue < 0:+ warnings.append("Negative revenue reported")++ # Profitability checks+ net_income = financial_data.get('net_income', 0)+ profit_margin = financial_data.get('profit_margin', 0)++ if revenue > 0 and net_income != 0:+ calculated_margin = net_income / revenue+ if abs(calculated_margin - profit_margin) > 0.02:+ warnings.append("Profit margin inconsistent with net income and revenue")++ # Balance sheet validation+ total_assets = financial_data.get('total_assets', 0)+ total_debt = financial_data.get('total_debt', 0)++ if total_debt > total_assets and total_assets > 0:+ warnings.append("Total debt exceeds total assets")++ # Ratio validation+ market_data = company_data.market_data+ pe_ratio = market_data.get('pe_ratio', 0)+ eps = financial_data.get('earnings_per_share', 0)++ if pe_ratio > 0 and eps > 0:+ calculated_price = pe_ratio * eps+ if abs(calculated_price - company_data.current_price) / company_data.current_price > 0.1:+ warnings.append("P/E ratio inconsistent with current price and EPS")++ return {'errors': errors, 'warnings': warnings}++ @staticmethod+ def validate_data_freshness(company_data: CompanyData, max_age_days: int = 7) -> bool:+ """Validate that data is recent enough for analysis"""+ if not company_data.last_updated:+ print("Warning: No timestamp available for data freshness check")+ return True++ age = datetime.now() - company_data.last_updated+ if age.days > max_age_days:+ print(f"Warning: Data is {age.days} days old (max recommended: {max_age_days} days)")++ return True+++# Utility functions for quick validation+def validate_all_inputs(valuation_method: ValuationMethod, **kwargs) -> bool:+ """Master validation function for all models"""++ if valuation_method in [ValuationMethod.DDM_GORDON, ValuationMethod.DDM_TWO_STAGE,+ ValuationMethod.DDM_THREE_STAGE, ValuationMethod.DDM_H_MODEL]:+ return DDMValidator.validate_gordon_growth_inputs(+ kwargs.get('dividend', 0),+ kwargs.get('growth_rate', 0),+ kwargs.get('required_return', 0)+ )++ elif valuation_method in [ValuationMethod.DCF_FCFF, ValuationMethod.DCF_FCFE]:+ return DCFValidator.validate_fcf_inputs(+ kwargs.get('cash_flows', []),+ kwargs.get('discount_rate', 0),+ kwargs.get('terminal_value')+ )++ elif valuation_method in [ValuationMethod.MULTIPLES_PE, ValuationMethod.MULTIPLES_PB,+ ValuationMethod.MULTIPLES_PS, ValuationMethod.MULTIPLES_EV_EBITDA]:+ return MultiplesValidator.validate_multiple_values(+ kwargs.get('multiples', {})+ )++ elif valuation_method == ValuationMethod.RESIDUAL_INCOME:+ return ResidualIncomeValidator.validate_ri_inputs(+ kwargs.get('net_income', 0),+ kwargs.get('book_value', 0),+ kwargs.get('required_return', 0),+ kwargs.get('roe', 0)+ )++ return True+++def comprehensive_data_validation(company_data: CompanyData) -> Dict[str, Any]:+ """Run all validation checks on company data"""++ results = {+ 'data_integrity': CompanyDataValidator.validate_company_data(company_data),+ 'financial_ratios': CFAValidator.validate_financial_ratios(company_data.market_data),+ 'is_valid': True,+ 'critical_errors': []+ }++ # Check for critical errors that would prevent analysis+ if results['data_integrity']['errors']:+ results['is_valid'] = False+ results['critical_errors'].extend(results['data_integrity']['errors'])++ if results['financial_ratios']['errors']:+ results['is_valid'] = False+ results['critical_errors'].extend(results['financial_ratios']['errors'])++ return results\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/forecasting.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/forecasting.pynew file mode 100644index 000000000..d2776eb19--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/forecasting.py@@ -0,0 +1,29 @@++Equity Investment Forecasting Module+======================================++Company forecasting and projection models++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/fundamental_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/fundamental_analysis.pynew file mode 100644index 000000000..dd0fa63e2--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/fundamental_analysis.py@@ -0,0 +1,29 @@++Equity Investment Fundamental Analysis Module+======================================++Fundamental analysis and ratio calculations++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/industry_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/industry_analysis.pynew file mode 100644index 000000000..95ac6adb7--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/company_analysis/industry_analysis.py@@ -0,0 +1,1593 @@++Equity Investment Industry Analysis Module+======================================++Industry and sector analysis tools++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple+from dataclasses import dataclass+from enum import Enum+import warnings++from .base_models import (+ BaseCompanyAnalysisModel, CompanyData, ValidationError,+ FinceptAnalyticsError+)+++class IndustryClassificationSystem(Enum):+ """Industry classification systems"""+ GICS = "Global Industry Classification Standard"+ ICB = "Industry Classification Benchmark"+ NAICS = "North American Industry Classification System"+ SIC = "Standard Industrial Classification"+++class CompetitivePosition(Enum):+ """Competitive position categories"""+ MARKET_LEADER = "market_leader"+ STRONG_COMPETITOR = "strong_competitor"+ NICHE_PLAYER = "niche_player"+ STRUGGLING_COMPETITOR = "struggling_competitor"+++@dataclass+class IndustryMetrics:+ """Industry-level metrics and characteristics"""+ industry_name: str+ total_market_size: float+ growth_rate: float+ number_of_companies: int+ concentration_ratio: float+ average_roe: float+ average_margin: float+ cyclicality: str+ capital_intensity: str+ regulatory_environment: str+++@dataclass+class CompetitorProfile:+ """Individual competitor profile"""+ company_name: str+ symbol: str+ market_cap: float+ market_share: float+ revenue: float+ profit_margin: float+ competitive_advantages: List[str]+ weaknesses: List[str]+++@dataclass+class PortersFiveForcesAnalysis:+ """Porter's Five Forces analysis structure"""+ threat_of_new_entrants: Dict[str, Any]+ bargaining_power_suppliers: Dict[str, Any]+ bargaining_power_buyers: Dict[str, Any]+ threat_of_substitutes: Dict[str, Any]+ competitive_rivalry: Dict[str, Any]+ overall_attractiveness: str+++@dataclass+class PESTLEAnalysis:+ """PESTLE analysis structure"""+ political_factors: List[str]+ economic_factors: List[str]+ social_factors: List[str]+ technological_factors: List[str]+ legal_factors: List[str]+ environmental_factors: List[str]+ overall_impact: str+++class IndustryClassifier:+ """Industry classification and grouping"""++ def __init__(self):+ # GICS sector and industry mappings (simplified)+ self.gics_sectors = {+ 'Energy': ['Oil & Gas Exploration', 'Oil & Gas Refining', 'Coal & Consumable Fuels'],+ 'Materials': ['Chemicals', 'Metals & Mining', 'Paper & Forest Products'],+ 'Industrials': ['Aerospace & Defense', 'Airlines', 'Construction & Engineering'],+ 'Consumer Discretionary': ['Automobiles', 'Hotels & Restaurants', 'Retail'],+ 'Consumer Staples': ['Food & Beverages', 'Household Products', 'Tobacco'],+ 'Health Care': ['Biotechnology', 'Pharmaceuticals', 'Health Care Equipment'],+ 'Financials': ['Banks', 'Insurance', 'Real Estate'],+ 'Information Technology': ['Software', 'Semiconductors', 'IT Services'],+ 'Communication Services': ['Telecommunications', 'Media & Entertainment'],+ 'Utilities': ['Electric Utilities', 'Gas Utilities', 'Water Utilities'],+ 'Real Estate': ['REITs', 'Real Estate Management']+ }++ # Industry characteristics+ self.industry_characteristics = {+ 'Cyclical': ['Energy', 'Materials', 'Industrials', 'Consumer Discretionary'],+ 'Defensive': ['Consumer Staples', 'Health Care', 'Utilities'],+ 'Growth': ['Information Technology', 'Communication Services', 'Health Care'],+ 'Value': ['Financials', 'Energy', 'Materials']+ }++ def classify_company(self, company_data: CompanyData) -> Dict[str, str]:+ """Classify company by various systems"""++ sector = company_data.sector+ industry = company_data.industry++ # GICS classification+ gics_sector = sector+ gics_industry = industry++ # Determine industry characteristics+ characteristics = []+ for char_type, sectors in self.industry_characteristics.items():+ if sector in sectors:+ characteristics.append(char_type)++ return {+ 'gics_sector': gics_sector,+ 'gics_industry': gics_industry,+ 'industry_characteristics': characteristics,+ 'business_cycle_sensitivity': self.determine_cycle_sensitivity(sector),+ 'regulatory_intensity': self.determine_regulatory_intensity(sector)+ }++ def determine_cycle_sensitivity(self, sector: str) -> str:+ """Determine business cycle sensitivity"""+ high_sensitivity = ['Energy', 'Materials', 'Industrials', 'Consumer Discretionary', 'Financials']+ low_sensitivity = ['Consumer Staples', 'Health Care', 'Utilities']++ if sector in high_sensitivity:+ return "High"+ elif sector in low_sensitivity:+ return "Low"+ else:+ return "Medium"++ def determine_regulatory_intensity(self, sector: str) -> str:+ """Determine regulatory intensity"""+ high_regulation = ['Health Care', 'Financials', 'Utilities', 'Energy']+ medium_regulation = ['Information Technology', 'Communication Services']++ if sector in high_regulation:+ return "High"+ elif sector in medium_regulation:+ return "Medium"+ else:+ return "Low"+++class IndustryAnalyzer(BaseCompanyAnalysisModel):+ """Comprehensive industry analysis framework"""++ def __init__(self):+ super().__init__("Industry Analyzer", "Comprehensive industry and competitive analysis")+ self.classifier = IndustryClassifier()++ def validate_inputs(self, **kwargs) -> bool:+ """Validate inputs for industry analysis"""+ company_data = kwargs.get('company_data')+ if not isinstance(company_data, CompanyData):+ raise ValidationError("Valid CompanyData object required")+ return True++ def analyze_company(self, company_data: CompanyData) -> Dict[str, Any]:+ """Comprehensive industry analysis for a company"""++ analysis = {+ 'industry_overview': self.analyze_industry_overview(company_data),+ 'industry_structure': self.analyze_industry_structure(company_data),+ 'competitive_landscape': self.analyze_competitive_landscape(company_data),+ 'porters_five_forces': self.perform_porters_analysis(company_data),+ 'pestle_analysis': self.perform_pestle_analysis(company_data),+ 'company_positioning': self.analyze_company_positioning(company_data),+ 'industry_trends': self.identify_industry_trends(company_data),+ 'investment_implications': self.assess_investment_implications(company_data)+ }++ return analysis++ def analyze_industry_overview(self, company_data: CompanyData) -> Dict[str, Any]:+ """Analyze industry overview and characteristics"""++ classification = self.classifier.classify_company(company_data)++ # Industry size estimation (simplified - would use actual data)+ market_cap = company_data.market_cap+ estimated_market_size = self.estimate_industry_size(company_data.sector, market_cap)++ # Growth characteristics+ growth_profile = self.determine_growth_profile(company_data.sector)++ return {+ 'classification': classification,+ 'industry_size': {+ 'estimated_total_market': estimated_market_size,+ 'company_market_share': self.estimate_market_share(market_cap, estimated_market_size),+ 'size_category': self.categorize_industry_size(estimated_market_size)+ },+ 'growth_characteristics': growth_profile,+ 'industry_lifecycle': self.determine_industry_lifecycle(company_data),+ 'key_success_factors': self.identify_success_factors(company_data.sector),+ 'industry_risks': self.identify_industry_risks(company_data.sector)+ }++ def estimate_industry_size(self, sector: str, company_market_cap: float) -> float:+ """Estimate total industry market size"""++ # Simplified multipliers based on sector characteristics+ multipliers = {+ 'Information Technology': 50,+ 'Health Care': 40,+ 'Financials': 30,+ 'Consumer Discretionary': 35,+ 'Consumer Staples': 25,+ 'Industrials': 30,+ 'Energy': 20,+ 'Materials': 15,+ 'Utilities': 10,+ 'Communication Services': 25,+ 'Real Estate': 20+ }++ multiplier = multipliers.get(sector, 25)+ return company_market_cap * multiplier++ def estimate_market_share(self, company_market_cap: float, industry_size: float) -> float:+ """Estimate company's market share"""+ if industry_size > 0:+ return (company_market_cap / industry_size) * 100+ return 0++ def categorize_industry_size(self, industry_size: float) -> str:+ """Categorize industry by size"""+ if industry_size > 1_000_000_000_000: # $1T++ return "Very Large"+ elif industry_size > 500_000_000_000: # $500B++ return "Large"+ elif industry_size > 100_000_000_000: # $100B++ return "Medium"+ else:+ return "Small"++ def determine_growth_profile(self, sector: str) -> Dict[str, Any]:+ """Determine industry growth profile"""++ # Historical growth patterns by sector (simplified)+ growth_profiles = {+ 'Information Technology': {'historical_growth': 0.12, 'volatility': 'High', 'trend': 'Growing'},+ 'Health Care': {'historical_growth': 0.08, 'volatility': 'Medium', 'trend': 'Growing'},+ 'Consumer Discretionary': {'historical_growth': 0.06, 'volatility': 'High', 'trend': 'Cyclical'},+ 'Financials': {'historical_growth': 0.05, 'volatility': 'High', 'trend': 'Cyclical'},+ 'Consumer Staples': {'historical_growth': 0.04, 'volatility': 'Low', 'trend': 'Stable'},+ 'Industrials': {'historical_growth': 0.05, 'volatility': 'Medium', 'trend': 'Cyclical'},+ 'Energy': {'historical_growth': 0.02, 'volatility': 'Very High', 'trend': 'Declining'},+ 'Materials': {'historical_growth': 0.03, 'volatility': 'High', 'trend': 'Cyclical'},+ 'Utilities': {'historical_growth': 0.02, 'volatility': 'Low', 'trend': 'Stable'},+ 'Communication Services': {'historical_growth': 0.07, 'volatility': 'Medium', 'trend': 'Growing'},+ 'Real Estate': {'historical_growth': 0.04, 'volatility': 'Medium', 'trend': 'Cyclical'}+ }++ return growth_profiles.get(sector, {'historical_growth': 0.05, 'volatility': 'Medium', 'trend': 'Stable'})++ def determine_industry_lifecycle(self, company_data: CompanyData) -> str:+ """Determine industry lifecycle stage"""++ sector = company_data.sector+ growth_profile = self.determine_growth_profile(sector)++ growth_rate = growth_profile['historical_growth']++ if growth_rate > 0.10:+ return "Growth"+ elif growth_rate > 0.05:+ return "Mature"+ elif growth_rate > 0:+ return "Mature/Stable"+ else:+ return "Declining"++ def identify_success_factors(self, sector: str) -> List[str]:+ """Identify key success factors by sector"""++ success_factors = {+ 'Information Technology': [+ 'Innovation and R&D capability',+ 'Talent acquisition and retention',+ 'Scalable technology platforms',+ 'Network effects',+ 'Speed to market'+ ],+ 'Health Care': [+ 'R&D pipeline strength',+ 'Regulatory approval capabilities',+ 'Patent protection',+ 'Clinical trial success rates',+ 'Market access and distribution'+ ],+ 'Financials': [+ 'Risk management capabilities',+ 'Regulatory compliance',+ 'Technology infrastructure',+ 'Customer relationships',+ 'Capital adequacy'+ ],+ 'Consumer Discretionary': [+ 'Brand strength and recognition',+ 'Distribution network',+ 'Product innovation',+ 'Supply chain efficiency',+ 'Customer experience'+ ],+ 'Energy': [+ 'Reserve quality and quantity',+ 'Operational efficiency',+ 'Technology and innovation',+ 'Environmental compliance',+ 'Geographic diversification'+ ]+ }++ return success_factors.get(sector, [+ 'Operational efficiency',+ 'Market position',+ 'Financial strength',+ 'Innovation capability',+ 'Customer relationships'+ ])++ def identify_industry_risks(self, sector: str) -> List[str]:+ """Identify key industry risks by sector"""++ industry_risks = {+ 'Information Technology': [+ 'Technological obsolescence',+ 'Cybersecurity threats',+ 'Regulatory changes',+ 'Talent shortage',+ 'Market saturation'+ ],+ 'Health Care': [+ 'Regulatory approval risks',+ 'Patent cliff exposure',+ 'Pricing pressures',+ 'Clinical trial failures',+ 'Regulatory changes'+ ],+ 'Financials': [+ 'Interest rate risk',+ 'Credit risk',+ 'Regulatory changes',+ 'Economic cycles',+ 'Technology disruption'+ ],+ 'Energy': [+ 'Commodity price volatility',+ 'Environmental regulations',+ 'Geopolitical risks',+ 'Stranded asset risk',+ 'Energy transition'+ ]+ }++ return industry_risks.get(sector, [+ 'Economic cycles',+ 'Competitive pressure',+ 'Regulatory changes',+ 'Technology disruption',+ 'Supply chain disruption'+ ])++ def analyze_industry_structure(self, company_data: CompanyData) -> Dict[str, Any]:+ """Analyze industry structure and concentration"""++ # Market concentration analysis (simplified)+ market_cap = company_data.market_cap+ estimated_industry_size = self.estimate_industry_size(company_data.sector, market_cap)++ # Estimate concentration based on sector characteristics+ concentration_level = self.estimate_concentration(company_data.sector)++ # Barriers to entry+ entry_barriers = self.assess_entry_barriers(company_data.sector)++ # Industry profitability+ profitability_profile = self.assess_industry_profitability(company_data.sector)++ return {+ 'market_concentration': {+ 'concentration_level': concentration_level,+ 'estimated_hhi': self.estimate_hhi(concentration_level),+ 'market_structure': self.determine_market_structure(concentration_level)+ },+ 'barriers_to_entry': entry_barriers,+ 'profitability_profile': profitability_profile,+ 'competitive_dynamics': self.assess_competitive_dynamics(company_data.sector),+ 'industry_maturity': self.assess_industry_maturity(company_data.sector)+ }++ def estimate_concentration(self, sector: str) -> str:+ """Estimate industry concentration level"""++ high_concentration = ['Utilities', 'Communication Services', 'Aerospace & Defense']+ medium_concentration = ['Energy', 'Materials', 'Industrials', 'Health Care']+ low_concentration = ['Information Technology', 'Consumer Discretionary', 'Financials']++ if sector in high_concentration:+ return "High"+ elif sector in medium_concentration:+ return "Medium"+ else:+ return "Low"++ def estimate_hhi(self, concentration_level: str) -> int:+ """Estimate Herfindahl-Hirschman Index"""++ hhi_ranges = {+ 'High': 2000,+ 'Medium': 1200,+ 'Low': 800+ }++ return hhi_ranges.get(concentration_level, 1000)++ def determine_market_structure(self, concentration_level: str) -> str:+ """Determine market structure type"""++ if concentration_level == "High":+ return "Oligopoly"+ elif concentration_level == "Medium":+ return "Monopolistic Competition"+ else:+ return "Perfect Competition"++ def assess_entry_barriers(self, sector: str) -> Dict[str, str]:+ """Assess barriers to entry"""++ barrier_assessments = {+ 'Information Technology': {+ 'capital_requirements': 'Medium',+ 'regulatory_barriers': 'Low',+ 'technology_barriers': 'High',+ 'brand_loyalty': 'Medium',+ 'network_effects': 'High'+ },+ 'Health Care': {+ 'capital_requirements': 'Very High',+ 'regulatory_barriers': 'Very High',+ 'technology_barriers': 'High',+ 'brand_loyalty': 'High',+ 'network_effects': 'Low'+ },+ 'Utilities': {+ 'capital_requirements': 'Very High',+ 'regulatory_barriers': 'Very High',+ 'technology_barriers': 'Medium',+ 'brand_loyalty': 'Low',+ 'network_effects': 'High'+ },+ 'Financials': {+ 'capital_requirements': 'Very High',+ 'regulatory_barriers': 'Very High',+ 'technology_barriers': 'Medium',+ 'brand_loyalty': 'Medium',+ 'network_effects': 'Medium'+ }+ }++ return barrier_assessments.get(sector, {+ 'capital_requirements': 'Medium',+ 'regulatory_barriers': 'Medium',+ 'technology_barriers': 'Medium',+ 'brand_loyalty': 'Medium',+ 'network_effects': 'Low'+ })++ def assess_industry_profitability(self, sector: str) -> Dict[str, Any]:+ """Assess industry profitability characteristics"""++ # Historical average margins by sector (simplified)+ profitability_data = {+ 'Information Technology': {'avg_margin': 0.15, 'margin_stability': 'Medium', 'trend': 'Stable'},+ 'Health Care': {'avg_margin': 0.12, 'margin_stability': 'High', 'trend': 'Declining'},+ 'Financials': {'avg_margin': 0.20, 'margin_stability': 'Low', 'trend': 'Cyclical'},+ 'Consumer Staples': {'avg_margin': 0.08, 'margin_stability': 'High', 'trend': 'Stable'},+ 'Energy': {'avg_margin': 0.05, 'margin_stability': 'Very Low', 'trend': 'Volatile'},+ 'Utilities': {'avg_margin': 0.10, 'margin_stability': 'High', 'trend': 'Stable'}+ }++ return profitability_data.get(sector, {+ 'avg_margin': 0.08,+ 'margin_stability': 'Medium',+ 'trend': 'Stable'+ })++ def assess_competitive_dynamics(self, sector: str) -> Dict[str, str]:+ """Assess competitive dynamics"""++ dynamics = {+ 'Information Technology': {+ 'intensity': 'Very High',+ 'basis': 'Innovation and Speed',+ 'pricing_power': 'Medium',+ 'differentiation': 'High'+ },+ 'Health Care': {+ 'intensity': 'High',+ 'basis': 'Innovation and Quality',+ 'pricing_power': 'High',+ 'differentiation': 'Very High'+ },+ 'Utilities': {+ 'intensity': 'Low',+ 'basis': 'Regulation and Service',+ 'pricing_power': 'Low',+ 'differentiation': 'Low'+ },+ 'Energy': {+ 'intensity': 'High',+ 'basis': 'Cost and Efficiency',+ 'pricing_power': 'Low',+ 'differentiation': 'Low'+ }+ }++ return dynamics.get(sector, {+ 'intensity': 'Medium',+ 'basis': 'Price and Quality',+ 'pricing_power': 'Medium',+ 'differentiation': 'Medium'+ })++ def assess_industry_maturity(self, sector: str) -> str:+ """Assess industry maturity level"""++ mature_industries = ['Utilities', 'Consumer Staples', 'Energy', 'Materials']+ growth_industries = ['Information Technology', 'Health Care', 'Communication Services']++ if sector in mature_industries:+ return "Mature"+ elif sector in growth_industries:+ return "Growth"+ else:+ return "Transitional"+++class PortersFiveForcesAnalyzer:+ """Porter's Five Forces analysis framework"""++ def analyze_five_forces(self, company_data: CompanyData) -> PortersFiveForcesAnalysis:+ """Perform comprehensive Porter's Five Forces analysis"""++ sector = company_data.sector++ threat_new_entrants = self.analyze_threat_of_new_entrants(sector)+ supplier_power = self.analyze_supplier_power(sector)+ buyer_power = self.analyze_buyer_power(sector)+ threat_substitutes = self.analyze_threat_of_substitutes(sector)+ competitive_rivalry = self.analyze_competitive_rivalry(sector)++ # Overall industry attractiveness+ forces_scores = [+ threat_new_entrants['threat_level_score'],+ supplier_power['power_level_score'],+ buyer_power['power_level_score'],+ threat_substitutes['threat_level_score'],+ competitive_rivalry['intensity_score']+ ]++ avg_score = np.mean(forces_scores)++ if avg_score <= 2:+ attractiveness = "Highly Attractive"+ elif avg_score <= 3:+ attractiveness = "Moderately Attractive"+ elif avg_score <= 4:+ attractiveness = "Average Attractiveness"+ else:+ attractiveness = "Unattractive"++ return PortersFiveForcesAnalysis(+ threat_of_new_entrants=threat_new_entrants,+ bargaining_power_suppliers=supplier_power,+ bargaining_power_buyers=buyer_power,+ threat_of_substitutes=threat_substitutes,+ competitive_rivalry=competitive_rivalry,+ overall_attractiveness=attractiveness+ )++ def analyze_threat_of_new_entrants(self, sector: str) -> Dict[str, Any]:+ """Analyze threat of new entrants"""++ # Sector-specific entry barrier analysis+ entry_barriers = {+ 'Information Technology': {+ 'capital_requirements': 3, # 1-5 scale (1=low barrier, 5=high barrier)+ 'technology_complexity': 4,+ 'regulatory_requirements': 2,+ 'brand_loyalty': 3,+ 'network_effects': 4,+ 'access_to_distribution': 3+ },+ 'Health Care': {+ 'capital_requirements': 5,+ 'technology_complexity': 5,+ 'regulatory_requirements': 5,+ 'brand_loyalty': 4,+ 'network_effects': 2,+ 'access_to_distribution': 4+ },+ 'Utilities': {+ 'capital_requirements': 5,+ 'technology_complexity': 3,+ 'regulatory_requirements': 5,+ 'brand_loyalty': 2,+ 'network_effects': 5,+ 'access_to_distribution': 5+ }+ }++ barriers = entry_barriers.get(sector, {+ 'capital_requirements': 3,+ 'technology_complexity': 3,+ 'regulatory_requirements': 3,+ 'brand_loyalty': 3,+ 'network_effects': 3,+ 'access_to_distribution': 3+ })++ avg_barrier_strength = np.mean(list(barriers.values()))+ threat_level_score = 6 - avg_barrier_strength # Inverse relationship++ if threat_level_score <= 2:+ threat_level = "Low"+ elif threat_level_score <= 3:+ threat_level = "Medium"+ else:+ threat_level = "High"++ return {+ 'entry_barriers': barriers,+ 'threat_level': threat_level,+ 'threat_level_score': threat_level_score,+ 'key_barriers': [k for k, v in barriers.items() if v >= 4],+ 'analysis': f"Entry barriers are {'strong' if avg_barrier_strength >= 4 else 'moderate' if avg_barrier_strength >= 3 else 'weak'}"+ }++ def analyze_supplier_power(self, sector: str) -> Dict[str, Any]:+ """Analyze bargaining power of suppliers"""++ supplier_power_factors = {+ 'Information Technology': {+ 'supplier_concentration': 3,+ 'switching_costs': 3,+ 'input_importance': 4,+ 'substitute_inputs': 3,+ 'forward_integration_threat': 2+ },+ 'Health Care': {+ 'supplier_concentration': 4,+ 'switching_costs': 4,+ 'input_importance': 5,+ 'substitute_inputs': 2,+ 'forward_integration_threat': 2+ },+ 'Automotive': {+ 'supplier_concentration': 4,+ 'switching_costs': 4,+ 'input_importance': 4,+ 'substitute_inputs': 3,+ 'forward_integration_threat': 3+ }+ }++ factors = supplier_power_factors.get(sector, {+ 'supplier_concentration': 3,+ 'switching_costs': 3,+ 'input_importance': 3,+ 'substitute_inputs': 3,+ 'forward_integration_threat': 3+ })++ avg_power = np.mean(list(factors.values()))++ if avg_power >= 4:+ power_level = "High"+ elif avg_power >= 3:+ power_level = "Medium"+ else:+ power_level = "Low"++ return {+ 'power_factors': factors,+ 'power_level': power_level,+ 'power_level_score': avg_power,+ 'key_factors': [k for k, v in factors.items() if v >= 4],+ 'analysis': f"Supplier power is {power_level.lower()} due to {', '.join([k.replace('_', ' ') for k, v in factors.items() if v >= 4])}"+ }++ def analyze_buyer_power(self, sector: str) -> Dict[str, Any]:+ """Analyze bargaining power of buyers"""++ buyer_power_factors = {+ 'Information Technology': {+ 'buyer_concentration': 3,+ 'switching_costs': 2,+ 'product_importance': 4,+ 'substitute_products': 3,+ 'backward_integration_threat': 2,+ 'price_sensitivity': 3+ },+ 'Health Care': {+ 'buyer_concentration': 4,+ 'switching_costs': 4,+ 'product_importance': 5,+ 'substitute_products': 2,+ 'backward_integration_threat': 1,+ 'price_sensitivity': 4+ },+ 'Retail': {+ 'buyer_concentration': 2,+ 'switching_costs': 1,+ 'product_importance': 2,+ 'substitute_products': 4,+ 'backward_integration_threat': 2,+ 'price_sensitivity': 5+ }+ }++ factors = buyer_power_factors.get(sector, {+ 'buyer_concentration': 3,+ 'switching_costs': 3,+ 'product_importance': 3,+ 'substitute_products': 3,+ 'backward_integration_threat': 3,+ 'price_sensitivity': 3+ })++ # Adjust for factors that reduce buyer power+ power_reducing_factors = ['switching_costs', 'product_importance']+ for factor in power_reducing_factors:+ if factor in factors:+ factors[factor] = 6 - factors[factor] # Invert scale++ avg_power = np.mean(list(factors.values()))++ if avg_power >= 4:+ power_level = "High"+ elif avg_power >= 3:+ power_level = "Medium"+ else:+ power_level = "Low"++ return {+ 'power_factors': buyer_power_factors.get(sector, factors),+ 'power_level': power_level,+ 'power_level_score': avg_power,+ 'key_factors': [k for k, v in factors.items() if v >= 4],+ 'analysis': f"Buyer power is {power_level.lower()}"+ }++ def analyze_threat_of_substitutes(self, sector: str) -> Dict[str, Any]:+ """Analyze threat of substitute products"""++ substitute_factors = {+ 'Information Technology': {+ 'substitute_availability': 4,+ 'switching_costs': 3,+ 'substitute_performance': 3,+ 'price_performance': 3+ },+ 'Energy': {+ 'substitute_availability': 4,+ 'switching_costs': 4,+ 'substitute_performance': 3,+ 'price_performance': 4+ },+ 'Transportation': {+ 'substitute_availability': 3,+ 'switching_costs': 3,+ 'substitute_performance': 3,+ 'price_performance': 3+ }+ }++ factors = substitute_factors.get(sector, {+ 'substitute_availability': 3,+ 'switching_costs': 3,+ 'substitute_performance': 3,+ 'price_performance': 3+ })++ # Switching costs reduce threat+ factors['switching_costs'] = 6 - factors['switching_costs']++ avg_threat = np.mean(list(factors.values()))++ if avg_threat >= 4:+ threat_level = "High"+ elif avg_threat >= 3:+ threat_level = "Medium"+ else:+ threat_level = "Low"++ return {+ 'substitute_factors': substitute_factors.get(sector, factors),+ 'threat_level': threat_level,+ 'threat_level_score': avg_threat,+ 'key_factors': [k for k, v in factors.items() if v >= 4],+ 'analysis': f"Substitute threat is {threat_level.lower()}"+ }++ def analyze_competitive_rivalry(self, sector: str) -> Dict[str, Any]:+ """Analyze intensity of competitive rivalry"""++ rivalry_factors = {+ 'Information Technology': {+ 'number_of_competitors': 5,+ 'industry_growth': 2, # High growth reduces rivalry+ 'product_differentiation': 3,+ 'switching_costs': 2,+ 'exit_barriers': 3,+ 'fixed_costs': 3+ },+ 'Airlines': {+ 'number_of_competitors': 4,+ 'industry_growth': 3,+ 'product_differentiation': 2,+ 'switching_costs': 1,+ 'exit_barriers': 5,+ 'fixed_costs': 5+ },+ 'Utilities': {+ 'number_of_competitors': 2,+ 'industry_growth': 2,+ 'product_differentiation': 1,+ 'switching_costs': 4,+ 'exit_barriers': 5,+ 'fixed_costs': 5+ }+ }++ factors = rivalry_factors.get(sector, {+ 'number_of_competitors': 4,+ 'industry_growth': 3,+ 'product_differentiation': 3,+ 'switching_costs': 3,+ 'exit_barriers': 3,+ 'fixed_costs': 3+ })++ # Factors that reduce rivalry (invert scale)+ rivalry_reducing = ['industry_growth', 'product_differentiation', 'switching_costs']+ for factor in rivalry_reducing:+ if factor in factors:+ factors[factor] = 6 - factors[factor]++ avg_intensity = np.mean(list(factors.values()))++ if avg_intensity >= 4:+ intensity = "Very High"+ elif avg_intensity >= 3.5:+ intensity = "High"+ elif avg_intensity >= 2.5:+ intensity = "Medium"+ else:+ intensity = "Low"++ return {+ 'rivalry_factors': rivalry_factors.get(sector, factors),+ 'intensity': intensity,+ 'intensity_score': avg_intensity,+ 'key_factors': [k for k, v in factors.items() if v >= 4],+ 'analysis': f"Competitive rivalry is {intensity.lower()}"+ }+++class PESTLEAnalyzer:+ """PESTLE analysis framework"""++ def perform_pestle_analysis(self, company_data: CompanyData) -> PESTLEAnalysis:+ """Perform PESTLE analysis for industry"""++ sector = company_data.sector++ political_factors = self.analyze_political_factors(sector)+ economic_factors = self.analyze_economic_factors(sector)+ social_factors = self.analyze_social_factors(sector)+ technological_factors = self.analyze_technological_factors(sector)+ legal_factors = self.analyze_legal_factors(sector)+ environmental_factors = self.analyze_environmental_factors(sector)++ # Overall impact assessment+ factor_impacts = [+ len([f for f in political_factors if 'positive' not in f.lower()]),+ len([f for f in economic_factors if 'positive' not in f.lower()]),+ len([f for f in social_factors if 'positive' not in f.lower()]),+ len([f for f in technological_factors if 'threat' in f.lower() or 'disruption' in f.lower()]),+ len([f for f in legal_factors if 'risk' in f.lower() or 'compliance' in f.lower()]),+ len([f for f in environmental_factors if 'regulation' in f.lower() or 'pressure' in f.lower()])+ ]++ total_negative_factors = sum(factor_impacts)++ if total_negative_factors <= 5:+ overall_impact = "Favorable"+ elif total_negative_factors <= 10:+ overall_impact = "Mixed"+ else:+ overall_impact = "Challenging"++ return PESTLEAnalysis(+ political_factors=political_factors,+ economic_factors=economic_factors,+ social_factors=social_factors,+ technological_factors=technological_factors,+ legal_factors=legal_factors,+ environmental_factors=environmental_factors,+ overall_impact=overall_impact+ )++ def analyze_political_factors(self, sector: str) -> List[str]:+ """Analyze political factors affecting the industry"""++ political_factors_by_sector = {+ 'Health Care': [+ 'Healthcare policy changes',+ 'Drug pricing regulations',+ 'FDA approval processes',+ 'International trade policies',+ 'Government healthcare spending'+ ],+ 'Energy': [+ 'Energy policy and subsidies',+ 'Environmental regulations',+ 'Geopolitical stability',+ 'Carbon pricing policies',+ 'Infrastructure investment'+ ],+ 'Financials': [+ 'Banking regulations',+ 'Monetary policy',+ 'Tax policy changes',+ 'International sanctions',+ 'Political stability'+ ],+ 'Information Technology': [+ 'Data privacy regulations',+ 'Antitrust scrutiny',+ 'International trade tensions',+ 'Cybersecurity policies',+ 'Government technology spending'+ ]+ }++ return political_factors_by_sector.get(sector, [+ 'Regulatory changes',+ 'Tax policy shifts',+ 'Government spending',+ 'Political stability',+ 'International relations'+ ])++ def analyze_economic_factors(self, sector: str) -> List[str]:+ """Analyze economic factors affecting the industry"""++ economic_factors_by_sector = {+ 'Consumer Discretionary': [+ 'Consumer spending trends',+ 'Employment levels',+ 'Disposable income changes',+ 'Interest rate environment',+ 'Economic growth rates'+ ],+ 'Financials': [+ 'Interest rate cycles',+ 'Credit market conditions',+ 'Economic growth outlook',+ 'Inflation expectations',+ 'Currency exchange rates'+ ],+ 'Real Estate': [+ 'Interest rate environment',+ 'Economic growth trends',+ 'Employment levels',+ 'Population demographics',+ 'Government housing policies'+ ],+ 'Energy': [+ 'Commodity price cycles',+ 'Global economic growth',+ 'Currency fluctuations',+ 'Supply-demand dynamics',+ 'Energy transition economics'+ ]+ }++ return economic_factors_by_sector.get(sector, [+ 'Economic growth rates',+ 'Interest rate environment',+ 'Inflation trends',+ 'Employment levels',+ 'Consumer confidence'+ ])++ def analyze_social_factors(self, sector: str) -> List[str]:+ """Analyze social factors affecting the industry"""++ social_factors_by_sector = {+ 'Consumer Staples': [+ 'Health and wellness trends',+ 'Demographic shifts',+ 'Lifestyle changes',+ 'Cultural preferences',+ 'Social responsibility expectations'+ ],+ 'Health Care': [+ 'Aging population trends',+ 'Health awareness levels',+ 'Lifestyle disease prevalence',+ 'Healthcare access expectations',+ 'Social healthcare attitudes'+ ],+ 'Information Technology': [+ 'Digital adoption rates',+ 'Remote work trends',+ 'Privacy concerns',+ 'Social media usage',+ 'Educational technology needs'+ ],+ 'Automotive': [+ 'Transportation preferences',+ 'Environmental consciousness',+ 'Urbanization trends',+ 'Mobility service adoption',+ 'Safety awareness'+ ]+ }++ return social_factors_by_sector.get(sector, [+ 'Demographic changes',+ 'Cultural shifts',+ 'Lifestyle trends',+ 'Social values evolution',+ 'Consumer behavior changes'+ ])++ def analyze_technological_factors(self, sector: str) -> List[str]:+ """Analyze technological factors affecting the industry"""++ tech_factors_by_sector = {+ 'Information Technology': [+ 'AI and machine learning advancement',+ 'Cloud computing evolution',+ 'Cybersecurity developments',+ 'Quantum computing potential',+ 'IoT expansion'+ ],+ 'Health Care': [+ 'Biotechnology advances',+ 'Digital health solutions',+ 'Precision medicine development',+ 'Medical device innovation',+ 'Telemedicine growth'+ ],+ 'Automotive': [+ 'Electric vehicle technology',+ 'Autonomous driving development',+ 'Battery technology advances',+ 'Connected car features',+ 'Manufacturing automation'+ ],+ 'Financial Services': [+ 'Fintech innovation',+ 'Blockchain technology',+ 'Digital payment systems',+ 'Robo-advisory platforms',+ 'Regulatory technology'+ ]+ }++ return tech_factors_by_sector.get(sector, [+ 'Automation advances',+ 'Digital transformation',+ 'Innovation pace',+ 'Technology disruption threats',+ 'R&D developments'+ ])++ def analyze_legal_factors(self, sector: str) -> List[str]:+ """Analyze legal factors affecting the industry"""++ legal_factors_by_sector = {+ 'Health Care': [+ 'FDA regulatory requirements',+ 'Patent law changes',+ 'Healthcare compliance',+ 'International drug regulations',+ 'Liability and malpractice laws'+ ],+ 'Financials': [+ 'Banking compliance requirements',+ 'Consumer protection laws',+ 'Anti-money laundering regulations',+ 'International banking standards',+ 'Data protection compliance'+ ],+ 'Energy': [+ 'Environmental compliance',+ 'Safety regulations',+ 'Land use rights',+ 'International energy agreements',+ 'Carbon emission regulations'+ ],+ 'Information Technology': [+ 'Data privacy laws',+ 'Intellectual property protection',+ 'Antitrust regulations',+ 'International data transfer rules',+ 'Cybersecurity compliance'+ ]+ }++ return legal_factors_by_sector.get(sector, [+ 'Regulatory compliance requirements',+ 'Industry-specific laws',+ 'International regulations',+ 'Intellectual property protection',+ 'Employment law changes'+ ])++ def analyze_environmental_factors(self, sector: str) -> List[str]:+ """Analyze environmental factors affecting the industry"""++ environmental_factors_by_sector = {+ 'Energy': [+ 'Climate change policies',+ 'Carbon emission regulations',+ 'Renewable energy transition',+ 'Environmental impact assessments',+ 'Sustainability reporting requirements'+ ],+ 'Materials': [+ 'Resource scarcity concerns',+ 'Recycling and waste management',+ 'Environmental regulations',+ 'Sustainable sourcing requirements',+ 'Carbon footprint pressures'+ ],+ 'Automotive': [+ 'Emission standards',+ 'Electric vehicle mandates',+ 'Fuel efficiency requirements',+ 'End-of-life vehicle regulations',+ 'Sustainable manufacturing'+ ],+ 'Consumer Staples': [+ 'Sustainable packaging requirements',+ 'Organic and natural trends',+ 'Water usage regulations',+ 'Supply chain sustainability',+ 'Carbon footprint disclosure'+ ]+ }++ return environmental_factors_by_sector.get(sector, [+ 'Environmental regulations',+ 'Climate change impact',+ 'Sustainability requirements',+ 'Resource availability',+ 'Waste management regulations'+ ])+++class CompetitivePositionAnalyzer:+ """Analyze company's competitive position"""++ def analyze_competitive_position(self, company_data: CompanyData,+ industry_metrics: IndustryMetrics = None) -> Dict[str, Any]:+ """Analyze company's competitive position in industry"""++ financial_data = company_data.financial_data+ market_data = company_data.market_data++ # Market position metrics+ market_position = self.assess_market_position(company_data, industry_metrics)++ # Financial competitive metrics+ financial_position = self.assess_financial_position(company_data, industry_metrics)++ # Strategic position+ strategic_position = self.assess_strategic_position(company_data)++ # Overall competitive position+ position_score = self.calculate_position_score(market_position, financial_position, strategic_position)+ competitive_position = self.determine_competitive_position(position_score)++ return {+ 'market_position': market_position,+ 'financial_position': financial_position,+ 'strategic_position': strategic_position,+ 'overall_position': competitive_position,+ 'position_score': position_score,+ 'competitive_advantages': self.identify_competitive_advantages(company_data),+ 'competitive_disadvantages': self.identify_competitive_disadvantages(company_data),+ 'strategic_recommendations': self.generate_strategic_recommendations(company_data, competitive_position)+ }++ def assess_market_position(self, company_data: CompanyData,+ industry_metrics: IndustryMetrics = None) -> Dict[str, Any]:+ """Assess market position"""++ market_cap = company_data.market_cap++ # Estimate market share (simplified)+ if industry_metrics:+ estimated_market_share = (market_cap / industry_metrics.total_market_size) * 100+ else:+ # Use sector-based estimation+ sector_multiplier = {+ 'Information Technology': 50,+ 'Health Care': 40,+ 'Financials': 30+ }.get(company_data.sector, 35)++ estimated_industry_size = market_cap * sector_multiplier+ estimated_market_share = (market_cap / estimated_industry_size) * 100++ # Market position assessment+ if estimated_market_share > 20:+ market_position_category = "Market Leader"+ position_score = 5+ elif estimated_market_share > 10:+ market_position_category = "Major Player"+ position_score = 4+ elif estimated_market_share > 5:+ market_position_category = "Significant Player"+ position_score = 3+ elif estimated_market_share > 1:+ market_position_category = "Niche Player"+ position_score = 2+ else:+ market_position_category = "Small Player"+ position_score = 1++ return {+ 'estimated_market_share': estimated_market_share,+ 'market_position_category': market_position_category,+ 'position_score': position_score,+ 'market_cap_ranking': self.estimate_market_cap_ranking(company_data),+ 'brand_strength': self.assess_brand_strength(company_data)+ }++ def assess_financial_position(self, company_data: CompanyData,+ industry_metrics: IndustryMetrics = None) -> Dict[str, Any]:+ """Assess financial competitive position"""++ financial_data = company_data.financial_data++ # Get industry averages+ if industry_metrics:+ industry_roe = industry_metrics.average_roe+ industry_margin = industry_metrics.average_margin+ else:+ # Default industry averages+ industry_roe = 0.10+ industry_margin = 0.08++ company_roe = financial_data.get('roe', 0)+ company_margin = financial_data.get('net_margin', 0)++ # Financial strength score+ financial_score = 0++ # ROE comparison+ if company_roe > industry_roe * 1.5:+ financial_score += 2+ elif company_roe > industry_roe:+ financial_score += 1+ elif company_roe < industry_roe * 0.5:+ financial_score -= 1++ # Margin comparison+ if company_margin > industry_margin * 1.5:+ financial_score += 2+ elif company_margin > industry_margin:+ financial_score += 1+ elif company_margin < industry_margin * 0.5:+ financial_score -= 1++ # Debt position+ debt_to_equity = financial_data.get('debt_to_equity', 0)+ if debt_to_equity < 0.3:+ financial_score += 1+ elif debt_to_equity > 1.5:+ financial_score -= 1++ return {+ 'financial_strength_score': financial_score,+ 'roe_vs_industry': company_roe / industry_roe if industry_roe > 0 else 1,+ 'margin_vs_industry': company_margin / industry_margin if industry_margin > 0 else 1,+ 'debt_position': 'Conservative' if debt_to_equity < 0.5 else 'Aggressive' if debt_to_equity > 1.5 else 'Moderate',+ 'cash_position': self.assess_cash_position(company_data)+ }++ def assess_strategic_position(self, company_data: CompanyData) -> Dict[str, Any]:+ """Assess strategic competitive position"""++ # Innovation assessment (proxy metrics)+ market_data = company_data.market_data+ pb_ratio = market_data.get('pb_ratio', 0)++ # Innovation score based on market valuation premium+ if pb_ratio > 3:+ innovation_score = 3+ elif pb_ratio > 2:+ innovation_score = 2+ elif pb_ratio > 1:+ innovation_score = 1+ else:+ innovation_score = 0++ # Scale advantages+ market_cap = company_data.market_cap+ if market_cap > 50_000_000_000: # $50B++ scale_advantage = 3+ elif market_cap > 10_000_000_000: # $10B++ scale_advantage = 2+ elif market_cap > 1_000_000_000: # $1B++ scale_advantage = 1+ else:+ scale_advantage = 0++ return {+ 'innovation_score': innovation_score,+ 'scale_advantage': scale_advantage,+ 'diversification': self.assess_diversification(company_data),+ 'operational_efficiency': self.assess_operational_efficiency(company_data),+ 'strategic_focus': self.assess_strategic_focus(company_data)+ }++ def calculate_position_score(self, market_position: Dict, financial_position: Dict,+ strategic_position: Dict) -> float:+ """Calculate overall competitive position score"""++ market_score = market_position['position_score']+ financial_score = max(0, financial_position['financial_strength_score'] + 3) # Normalize to 0-5+ strategic_score = (strategic_position['innovation_score'] ++ strategic_position['scale_advantage']) / 2++ # Weighted average+ total_score = (market_score * 0.4 + financial_score * 0.4 + strategic_score * 0.2)+ return total_score++ def determine_competitive_position(self, position_score: float) -> CompetitivePosition:+ """Determine competitive position category"""++ if position_score >= 4:+ return CompetitivePosition.MARKET_LEADER+ elif position_score >= 3:+ return CompetitivePosition.STRONG_COMPETITOR+ elif position_score >= 2:+ return CompetitivePosition.NICHE_PLAYER+ else:+ return CompetitivePosition.STRUGGLING_COMPETITOR++ def estimate_market_cap_ranking(self, company_data: CompanyData) -> str:+ """Estimate market cap ranking within sector"""++ market_cap = company_data.market_cap++ if market_cap > 100_000_000_000: # $100B++ return "Top 5"+ elif market_cap > 50_000_000_000: # $50B++ return "Top 10"+ elif market_cap > 10_000_000_000: # $10B++ return "Top 25"+ elif market_cap > 1_000_000_000: # $1B++ return "Top 100"+ else:+ return "Outside Top 100"++ def assess_brand_strength(self, company_data: CompanyData) -> str:+ """Assess brand strength"""++ market_data = company_data.market_data+ pb_ratio = market_data.get('pb_ratio', 0)++ # Use P/B as proxy for brand/intangible value+ if pb_ratio > 5:+ return "Very Strong"+ elif pb_ratio > 3:+ return "Strong"+ elif pb_ratio > 1.5:+ return "Moderate"+ else:+ return "Weak"++ def assess_cash_position(self, company_data: CompanyData) -> str:+ """Assess cash position strength"""++ financial_data = company_data.financial_data+ current_ratio = financial_data.get('current_ratio', 0)++ if current_ratio > 2.5:+ return "Very Strong"+ elif current_ratio > 1.5:+ return "Strong"+ elif current_ratio > 1.0:+ return "Adequate"+ else:+ return "Weak"++ def assess_diversification(self, company_data: CompanyData) -> str:+ """Assess business diversification"""++ # Simplified assessment based on company size+ # Larger companies typically more diversified+ market_cap = company_data.market_cap++ if market_cap > 50_000_000_000:+ return "Highly Diversified"+ elif market_cap > 10_000_000_000:+ return "Moderately Diversified"+ else:+ return "Focused"++ def assess_operational_efficiency(self, company_data: CompanyData) -> str:+ """Assess operational efficiency"""++ financial_data = company_data.financial_data+ asset_turnover = financial_data.get('revenue', 0) / financial_data.get('total_assets', 1)++ if asset_turnover > 1.5:+ return "High"+ elif asset_turnover > 1.0:+ return "Average"+ else:+ return "Low"++ def assess_strategic_focus(self, company_data: CompanyData) -> str:+ """Assess strategic focus"""++ # Simplified assessment+ return "Focused" # Would require more detailed business analysis++ def identify_competitive_advantages(self, company_data: CompanyData) -> List[str]:+ """Identify key competitive advantages"""++ advantages = []+ financial_data = company_data.financial_data+ market_data = company_data.market_data++ # Financial advantages+ if financial_data.get('roe', 0) > 0.15:+ advantages.append("Strong profitability")++ if financial_data.get('debt_to_equity', 0) < 0.3:+ advantages.append("Strong balance sheet")++ # Market advantages+ if company_data.market_cap > 10_000_000_000:+ advantages.append("Scale advantages")++ if market_data.get('pb_ratio', 0) > 3:+ advantages.append("Strong brand/intangibles")++ # Operational advantages+ asset_turnover = financial_data.get('revenue', 0) / financial_data.get('total_assets', 1)+ if asset_turnover > 1.5:+ advantages.append("Operational efficiency")++ return advantages if advantages else ["No clear competitive advantages identified"]++ def identify_competitive_disadvantages(self, company_data: CompanyData) -> List[str]:+ """Identify competitive disadvantages"""++ disadvantages = []+ financial_data = company_data.financial_data++ if financial_data.get('roe', 0) < 0:+ disadvantages.append("Poor profitability")++ if financial_data.get('debt_to_equity', 0) > 2:+ disadvantages.append("High leverage")++ if financial_data.get('current_ratio', 0) < 1:+ disadvantages.append("Liquidity constraints")++ if company_data.market_cap < 1_000_000_000:+ disadvantages.append("Limited scale")++ return disadvantages if disadvantages else ["No significant competitive disadvantages identified"]++ def generate_strategic_recommendations(self, company_data: CompanyData,+ position: CompetitivePosition) -> List[str]:+ """Generate strategic recommendations based on competitive position"""++ recommendations = []++ if position == CompetitivePosition.MARKET_LEADER:+ recommendations = [+ "Maintain market leadership through innovation",+ "Consider strategic acquisitions for growth",+ "Invest in emerging markets or technologies",+ "Optimize operational efficiency"+ ]++ elif position == CompetitivePosition.STRONG_COMPETITOR:+ recommendations = [+ "Focus on differentiation strategies",+ "Identify niche market opportunities",+ "Strengthen core competencies",+ "Consider strategic partnerships"+ ]++ elif position == CompetitivePosition.NICHE_PLAYER:+ recommendations = [+ "Defend niche market position",+ "Explore adjacent market opportunities",+ "Build strategic alliances",+ "Focus on customer loyalty"+ ]++ else: # STRUGGLING_COMPETITOR+ recommendations = [+ "Restructure operations for efficiency",+ "Consider strategic alternatives",+ "Focus on core profitable segments",+ "Improve financial position"+ ]++ return recommendations+++# Convenience functions+def quick_industry_analysis(company_data: CompanyData) -> Dict[str, Any]:+ """Quick industry analysis"""+ analyzer = IndustryAnalyzer()+ return analyzer.analyze_company(company_data)+++def porters_five_forces(company_data: CompanyData) -> PortersFiveForcesAnalysis:+ """Quick Porter's Five Forces analysis"""+ analyzer = PortersFiveForcesAnalyzer()+ return analyzer.analyze_five_forces(company_data)+++def pestle_analysis(company_data: CompanyData) -> PESTLEAnalysis:+ """Quick PESTLE analysis"""+ analyzer = PESTLEAnalyzer()+ return analyzer.perform_pestle_analysis(company_data)+++def competitive_position_analysis(company_data: CompanyData) -> Dict[str, Any]:+ """Quick competitive position analysis"""+ analyzer = CompetitivePositionAnalyzer()+ return analyzer.analyze_competitive_position(company_data)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dcf_models.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dcf_models.pynew file mode 100644index 000000000..95000992a--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dcf_models.py@@ -0,0 +1,628 @@++Equity Investment Dcf Models Module+======================================++Discounted cash flow valuation models++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple, Union+from dataclasses import dataclass+import math++from .base_models import (+ BaseValuationModel, CompanyData, MarketData, ValuationResult,+ ValuationMethod, CalculationEngine, ModelValidator, ValidationError+)+++@dataclass+class DCFParameters:+ """Parameters for DCF calculations"""+ cash_flows: List[float]+ discount_rate: float+ terminal_growth_rate: Optional[float] = None+ terminal_value: Optional[float] = None+ projection_years: int = 5+++class FCFFModel(BaseValuationModel):+ """Free Cash Flow to Firm Model"""++ def __init__(self):+ super().__init__("FCFF Model", "Free Cash Flow to Firm valuation")+ self.valuation_method = ValuationMethod.DCF_FCFF++ def validate_inputs(self, wacc: float, fcff_projections: List[float],+ terminal_growth: float = None) -> bool:+ """Validate FCFF model inputs"""+ ModelValidator.validate_percentage(wacc, "WACC")++ if not fcff_projections or len(fcff_projections) == 0:+ raise ValidationError("FCFF projections cannot be empty")++ if terminal_growth is not None:+ ModelValidator.validate_percentage(terminal_growth, "Terminal growth rate", allow_negative=True)+ ModelValidator.validate_growth_vs_required_return(terminal_growth, wacc)++ return True++ def calculate_fcff_from_components(self, ebit: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float) -> float:+ """Calculate FCFF from financial statement components"""+ return CalculationEngine.free_cash_flow_to_firm(ebit, tax_rate, depreciation,+ capex, working_capital_change)++ def calculate_fcff_from_ebitda(self, ebitda: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float) -> float:+ """Calculate FCFF starting from EBITDA"""+ ebit = ebitda - depreciation+ return self.calculate_fcff_from_components(ebit, tax_rate, depreciation,+ capex, working_capital_change)++ def calculate_fcff_from_net_income(self, net_income: float, interest_expense: float,+ tax_rate: float, depreciation: float, capex: float,+ working_capital_change: float) -> float:+ """Calculate FCFF starting from net income"""+ # Add back after-tax interest expense+ after_tax_interest = interest_expense * (1 - tax_rate)+ unlevered_net_income = net_income + after_tax_interest++ return unlevered_net_income + depreciation - capex - working_capital_change++ def calculate_fcff_from_cfo(self, cfo: float, interest_expense: float, tax_rate: float,+ capex: float) -> float:+ """Calculate FCFF from Cash Flow from Operations"""+ after_tax_interest = interest_expense * (1 - tax_rate)+ return cfo + after_tax_interest - capex++ def calculate_terminal_value(self, final_fcff: float, terminal_growth: float,+ wacc: float) -> float:+ """Calculate terminal value using Gordon Growth"""+ if terminal_growth >= wacc:+ raise ValidationError("Terminal growth rate must be less than WACC")++ terminal_fcff = final_fcff * (1 + terminal_growth)+ return terminal_fcff / (wacc - terminal_growth)++ def calculate_enterprise_value(self, fcff_projections: List[float], wacc: float,+ terminal_growth: float = None, terminal_value: float = None) -> Dict[str, float]:+ """Calculate enterprise value from FCFF projections"""++ # Present value of projected cash flows+ pv_fcff = 0+ pv_details = []++ for year, fcff in enumerate(fcff_projections, 1):+ pv = CalculationEngine.present_value(fcff, wacc, year)+ pv_fcff += pv+ pv_details.append({'year': year, 'fcff': fcff, 'pv': pv})++ # Terminal value+ if terminal_value is None:+ if terminal_growth is None:+ raise ValidationError("Either terminal_growth or terminal_value must be provided")+ terminal_value = self.calculate_terminal_value(fcff_projections[-1], terminal_growth, wacc)++ # Present value of terminal value+ pv_terminal = CalculationEngine.present_value(terminal_value, wacc, len(fcff_projections))++ # Total enterprise value+ enterprise_value = pv_fcff + pv_terminal++ return {+ 'pv_fcff': pv_fcff,+ 'terminal_value': terminal_value,+ 'pv_terminal': pv_terminal,+ 'enterprise_value': enterprise_value,+ 'pv_details': pv_details+ }++ def calculate_equity_value(self, enterprise_value: float, cash: float,+ total_debt: float, preferred_stock: float = 0) -> float:+ """Calculate equity value from enterprise value"""+ return enterprise_value + cash - total_debt - preferred_stock++ def calculate(self, fcff_projections: List[float], wacc: float, shares_outstanding: float,+ terminal_growth: float = None, terminal_value: float = None,+ cash: float = 0, total_debt: float = 0, preferred_stock: float = 0,+ current_price: float = None) -> ValuationResult:+ """Calculate valuation using FCFF model"""++ # Validate inputs+ self.validate_inputs(wacc, fcff_projections, terminal_growth)++ # Calculate enterprise value+ ev_components = self.calculate_enterprise_value(fcff_projections, wacc,+ terminal_growth, terminal_value)++ # Calculate equity value+ equity_value = self.calculate_equity_value(ev_components['enterprise_value'],+ cash, total_debt, preferred_stock)++ # Calculate per-share value+ intrinsic_value = equity_value / shares_outstanding if shares_outstanding > 0 else 0++ # Store assumptions+ assumptions = {+ 'wacc': wacc,+ 'terminal_growth_rate': terminal_growth,+ 'projection_years': len(fcff_projections),+ 'terminal_value_multiple': ev_components['pv_terminal'] / ev_components['enterprise_value'] * 100,+ 'cash': cash,+ 'total_debt': total_debt,+ 'preferred_stock': preferred_stock,+ 'shares_outstanding': shares_outstanding,+ 'model_type': 'FCFF DCF Model'+ }++ # Detailed calculations+ calculation_details = {+ 'fcff_projections': fcff_projections,+ 'pv_fcff': ev_components['pv_fcff'],+ 'terminal_value': ev_components['terminal_value'],+ 'pv_terminal': ev_components['pv_terminal'],+ 'enterprise_value': ev_components['enterprise_value'],+ 'equity_value': equity_value,+ 'intrinsic_value_per_share': intrinsic_value,+ 'pv_details': ev_components['pv_details']+ }++ # Generate recommendation+ recommendation = "HOLD"+ upside_downside = 0+ if current_price:+ recommendation = self.generate_recommendation(intrinsic_value, current_price)+ upside_downside = self.calculate_upside_downside(intrinsic_value, current_price)++ return ValuationResult(+ method=self.valuation_method,+ intrinsic_value=intrinsic_value,+ current_price=current_price or 0,+ recommendation=recommendation,+ upside_downside=upside_downside,+ confidence_level="MEDIUM",+ assumptions=assumptions,+ calculation_details=calculation_details+ )+++class FCFEModel(BaseValuationModel):+ """Free Cash Flow to Equity Model"""++ def __init__(self):+ super().__init__("FCFE Model", "Free Cash Flow to Equity valuation")+ self.valuation_method = ValuationMethod.DCF_FCFE++ def validate_inputs(self, required_return: float, fcfe_projections: List[float],+ terminal_growth: float = None) -> bool:+ """Validate FCFE model inputs"""+ ModelValidator.validate_percentage(required_return, "Required return on equity")++ if not fcfe_projections or len(fcfe_projections) == 0:+ raise ValidationError("FCFE projections cannot be empty")++ if terminal_growth is not None:+ ModelValidator.validate_percentage(terminal_growth, "Terminal growth rate", allow_negative=True)+ ModelValidator.validate_growth_vs_required_return(terminal_growth, required_return)++ return True++ def calculate_fcfe_from_components(self, net_income: float, depreciation: float, capex: float,+ working_capital_change: float, net_borrowing: float) -> float:+ """Calculate FCFE from financial statement components"""+ return CalculationEngine.free_cash_flow_to_equity(net_income, depreciation, capex,+ working_capital_change, net_borrowing)++ def calculate_fcfe_from_fcff(self, fcff: float, interest_expense: float, tax_rate: float,+ net_borrowing: float) -> float:+ """Calculate FCFE from FCFF"""+ after_tax_interest = interest_expense * (1 - tax_rate)+ return fcff - after_tax_interest + net_borrowing++ def calculate_fcfe_from_ebit(self, ebit: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float,+ interest_expense: float, net_borrowing: float) -> float:+ """Calculate FCFE starting from EBIT"""+ # Calculate net income+ ebt = ebit - interest_expense+ net_income = ebt * (1 - tax_rate)++ return self.calculate_fcfe_from_components(net_income, depreciation, capex,+ working_capital_change, net_borrowing)++ def calculate_fcfe_from_ebitda(self, ebitda: float, tax_rate: float, depreciation: float,+ capex: float, working_capital_change: float,+ interest_expense: float, net_borrowing: float) -> float:+ """Calculate FCFE starting from EBITDA"""+ ebit = ebitda - depreciation+ return self.calculate_fcfe_from_ebit(ebit, tax_rate, depreciation, capex,+ working_capital_change, interest_expense, net_borrowing)++ def calculate_fcfe_from_cfo(self, cfo: float, capex: float, net_borrowing: float) -> float:+ """Calculate FCFE from Cash Flow from Operations"""+ return cfo - capex + net_borrowing++ def calculate_terminal_value(self, final_fcfe: float, terminal_growth: float,+ required_return: float) -> float:+ """Calculate terminal value using Gordon Growth"""+ if terminal_growth >= required_return:+ raise ValidationError("Terminal growth rate must be less than required return")++ terminal_fcfe = final_fcfe * (1 + terminal_growth)+ return terminal_fcfe / (required_return - terminal_growth)++ def calculate_equity_value(self, fcfe_projections: List[float], required_return: float,+ terminal_growth: float = None, terminal_value: float = None) -> Dict[str, float]:+ """Calculate equity value from FCFE projections"""++ # Present value of projected cash flows+ pv_fcfe = 0+ pv_details = []++ for year, fcfe in enumerate(fcfe_projections, 1):+ pv = CalculationEngine.present_value(fcfe, required_return, year)+ pv_fcfe += pv+ pv_details.append({'year': year, 'fcfe': fcfe, 'pv': pv})++ # Terminal value+ if terminal_value is None:+ if terminal_growth is None:+ raise ValidationError("Either terminal_growth or terminal_value must be provided")+ terminal_value = self.calculate_terminal_value(fcfe_projections[-1], terminal_growth, required_return)++ # Present value of terminal value+ pv_terminal = CalculationEngine.present_value(terminal_value, required_return, len(fcfe_projections))++ # Total equity value+ equity_value = pv_fcfe + pv_terminal++ return {+ 'pv_fcfe': pv_fcfe,+ 'terminal_value': terminal_value,+ 'pv_terminal': pv_terminal,+ 'equity_value': equity_value,+ 'pv_details': pv_details+ }++ def calculate(self, fcfe_projections: List[float], required_return: float, shares_outstanding: float,+ terminal_growth: float = None, terminal_value: float = None,+ current_price: float = None) -> ValuationResult:+ """Calculate valuation using FCFE model"""++ # Validate inputs+ self.validate_inputs(required_return, fcfe_projections, terminal_growth)++ # Calculate equity value+ equity_components = self.calculate_equity_value(fcfe_projections, required_return,+ terminal_growth, terminal_value)++ # Calculate per-share value+ intrinsic_value = equity_components['equity_value'] / shares_outstanding if shares_outstanding > 0 else 0++ # Store assumptions+ assumptions = {+ 'required_return': required_return,+ 'terminal_growth_rate': terminal_growth,+ 'projection_years': len(fcfe_projections),+ 'terminal_value_multiple': equity_components['pv_terminal'] / equity_components['equity_value'] * 100,+ 'shares_outstanding': shares_outstanding,+ 'model_type': 'FCFE DCF Model'+ }++ # Detailed calculations+ calculation_details = {+ 'fcfe_projections': fcfe_projections,+ 'pv_fcfe': equity_components['pv_fcfe'],+ 'terminal_value': equity_components['terminal_value'],+ 'pv_terminal': equity_components['pv_terminal'],+ 'equity_value': equity_components['equity_value'],+ 'intrinsic_value_per_share': intrinsic_value,+ 'pv_details': equity_components['pv_details']+ }++ # Generate recommendation+ recommendation = "HOLD"+ upside_downside = 0+ if current_price:+ recommendation = self.generate_recommendation(intrinsic_value, current_price)+ upside_downside = self.calculate_upside_downside(intrinsic_value, current_price)++ return ValuationResult(+ method=self.valuation_method,+ intrinsic_value=intrinsic_value,+ current_price=current_price or 0,+ recommendation=recommendation,+ upside_downside=upside_downside,+ confidence_level="MEDIUM",+ assumptions=assumptions,+ calculation_details=calculation_details+ )+++class DCFSensitivityAnalyzer:+ """Sensitivity analysis for DCF models"""++ @staticmethod+ def wacc_sensitivity_analysis(base_fcff_projections: List[float], base_wacc: float,+ terminal_growth: float, shares_outstanding: float,+ wacc_range: Tuple[float, float] = (-0.02, 0.02),+ steps: int = 5) -> pd.DataFrame:+ """Perform sensitivity analysis on WACC"""++ fcff_model = FCFFModel()+ results = []++ wacc_min, wacc_max = wacc_range+ wacc_values = np.linspace(base_wacc + wacc_min, base_wacc + wacc_max, steps)++ for wacc in wacc_values:+ try:+ ev_components = fcff_model.calculate_enterprise_value(base_fcff_projections, wacc, terminal_growth)+ equity_value = fcff_model.calculate_equity_value(ev_components['enterprise_value'], 0, 0, 0)+ per_share_value = equity_value / shares_outstanding++ results.append({+ 'wacc': wacc,+ 'enterprise_value': ev_components['enterprise_value'],+ 'equity_value': equity_value,+ 'per_share_value': per_share_value+ })+ except:+ continue++ return pd.DataFrame(results)++ @staticmethod+ def terminal_growth_sensitivity_analysis(base_fcff_projections: List[float], wacc: float,+ base_terminal_growth: float, shares_outstanding: float,+ growth_range: Tuple[float, float] = (-0.01, 0.01),+ steps: int = 5) -> pd.DataFrame:+ """Perform sensitivity analysis on terminal growth rate"""++ fcff_model = FCFFModel()+ results = []++ growth_min, growth_max = growth_range+ growth_values = np.linspace(base_terminal_growth + growth_min,+ base_terminal_growth + growth_max, steps)++ for growth in growth_values:+ if growth >= wacc:+ continue++ try:+ ev_components = fcff_model.calculate_enterprise_value(base_fcff_projections, wacc, growth)+ equity_value = fcff_model.calculate_equity_value(ev_components['enterprise_value'], 0, 0, 0)+ per_share_value = equity_value / shares_outstanding++ results.append({+ 'terminal_growth': growth,+ 'enterprise_value': ev_components['enterprise_value'],+ 'equity_value': equity_value,+ 'per_share_value': per_share_value+ })+ except:+ continue++ return pd.DataFrame(results)++ @staticmethod+ def two_way_sensitivity_analysis(base_fcff_projections: List[float], base_wacc: float,+ base_terminal_growth: float, shares_outstanding: float,+ wacc_range: Tuple[float, float] = (-0.015, 0.015),+ growth_range: Tuple[float, float] = (-0.01, 0.01),+ steps: int = 5) -> pd.DataFrame:+ """Perform two-way sensitivity analysis on WACC and terminal growth"""++ fcff_model = FCFFModel()+ results = []++ wacc_min, wacc_max = wacc_range+ growth_min, growth_max = growth_range++ wacc_values = np.linspace(base_wacc + wacc_min, base_wacc + wacc_max, steps)+ growth_values = np.linspace(base_terminal_growth + growth_min,+ base_terminal_growth + growth_max, steps)++ for wacc in wacc_values:+ for growth in growth_values:+ if growth >= wacc:+ continue++ try:+ ev_components = fcff_model.calculate_enterprise_value(base_fcff_projections, wacc, growth)+ equity_value = fcff_model.calculate_equity_value(ev_components['enterprise_value'], 0, 0, 0)+ per_share_value = equity_value / shares_outstanding++ results.append({+ 'wacc': wacc,+ 'terminal_growth': growth,+ 'per_share_value': per_share_value+ })+ except:+ continue++ df = pd.DataFrame(results)+ return df.pivot_table(values='per_share_value', index='wacc', columns='terminal_growth')+++class DCFAnalyzer:+ """Comprehensive DCF analysis tool"""++ def __init__(self):+ self.fcff_model = FCFFModel()+ self.fcfe_model = FCFEModel()+ self.sensitivity_analyzer = DCFSensitivityAnalyzer()++ def compare_dcf_models(self, company_data: CompanyData, market_data: MarketData,+ projections: Dict[str, List[float]]) -> Dict[str, ValuationResult]:+ """Compare FCFF and FCFE valuations"""++ results = {}++ # FCFF Model+ if 'fcff' in projections:+ try:+ # Estimate WACC (simplified)+ wacc = market_data.required_return * 0.8 # Rough approximation++ results['fcff'] = self.fcff_model.calculate(+ projections['fcff'], wacc, company_data.shares_outstanding,+ market_data.growth_rate, None,+ company_data.financial_data.get('cash', 0),+ company_data.financial_data.get('total_debt', 0),+ 0, company_data.current_price+ )+ except Exception as e:+ results['fcff'] = f"Error: {str(e)}"++ # FCFE Model+ if 'fcfe' in projections:+ try:+ results['fcfe'] = self.fcfe_model.calculate(+ projections['fcfe'], market_data.required_return,+ company_data.shares_outstanding, market_data.growth_rate,+ None, company_data.current_price+ )+ except Exception as e:+ results['fcfe'] = f"Error: {str(e)}"++ return results++ def calculate_implicit_forecasts(self, current_price: float, shares_outstanding: float,+ wacc: float, terminal_growth: float,+ projection_years: int = 5) -> Dict[str, Any]:+ """Calculate implicit FCFF forecasts based on current market price"""++ # This is a reverse DCF - what FCF growth is implied by current price+ # Simplified approach: assume constant growth to terminal value++ # Market equity value+ market_equity_value = current_price * shares_outstanding++ # Assume terminal value is 80% of total value (typical assumption)+ terminal_value_percentage = 0.8+ pv_terminal = market_equity_value * terminal_value_percentage+ pv_growth_stage = market_equity_value * (1 - terminal_value_percentage)++ # Back-calculate required FCFF+ # This is simplified - actual implementation would be more complex+ implied_terminal_fcff = pv_terminal * (wacc - terminal_growth) / ((1 + wacc) ** projection_years)++ # Implied first year FCFF (assuming constant growth during projection period)+ growth_factor = ((1 + terminal_growth) ** projection_years)+ implied_initial_fcff = implied_terminal_fcff / growth_factor++ return {+ 'market_equity_value': market_equity_value,+ 'implied_terminal_fcff': implied_terminal_fcff,+ 'implied_initial_fcff': implied_initial_fcff,+ 'implied_growth_rate': terminal_growth,+ 'assumptions': {+ 'terminal_value_percentage': terminal_value_percentage,+ 'projection_years': projection_years,+ 'wacc': wacc,+ 'terminal_growth': terminal_growth+ }+ }++ def forecast_cash_flows(self, historical_financials: pd.DataFrame,+ growth_assumptions: Dict[str, float],+ projection_years: int = 5) -> Dict[str, List[float]]:+ """Forecast future cash flows based on historical data and assumptions"""++ # Get base year data (most recent year)+ base_year = historical_financials.iloc[-1]++ # Revenue growth assumption+ revenue_growth = growth_assumptions.get('revenue_growth', 0.05)++ # Margin assumptions+ ebitda_margin = growth_assumptions.get('ebitda_margin',+ base_year.get('ebitda', 0) / base_year.get('revenue', 1))+ tax_rate = growth_assumptions.get('tax_rate', 0.25)++ # Investment assumptions+ capex_percentage = growth_assumptions.get('capex_percentage', 0.03) # % of revenue+ depreciation_percentage = growth_assumptions.get('depreciation_percentage', 0.025)++ projections = {+ 'revenue': [],+ 'ebitda': [],+ 'fcff': [],+ 'fcfe': []+ }++ current_revenue = base_year.get('revenue', 0)++ for year in range(1, projection_years + 1):+ # Revenue projection+ current_revenue *= (1 + revenue_growth)+ projections['revenue'].append(current_revenue)++ # EBITDA projection+ ebitda = current_revenue * ebitda_margin+ projections['ebitda'].append(ebitda)++ # FCFF calculation+ depreciation = current_revenue * depreciation_percentage+ ebit = ebitda - depreciation+ capex = current_revenue * capex_percentage++ fcff = self.fcff_model.calculate_fcff_from_components(+ ebit, tax_rate, depreciation, capex, 0+ )+ projections['fcff'].append(fcff)++ # FCFE calculation (simplified)+ interest_expense = base_year.get('interest_expense', 0)+ net_borrowing = capex * 0.3 # Assume 30% debt financing++ fcfe = self.fcfe_model.calculate_fcfe_from_fcff(+ fcff, interest_expense, tax_rate, net_borrowing+ )+ projections['fcfe'].append(fcfe)++ return projections+++# Convenience functions+def fcff_valuation(fcff_projections: List[float], wacc: float, shares_outstanding: float,+ terminal_growth: float, cash: float = 0, debt: float = 0,+ current_price: float = None) -> ValuationResult:+ """Quick FCFF valuation"""+ model = FCFFModel()+ return model.calculate(fcff_projections, wacc, shares_outstanding, terminal_growth,+ None, cash, debt, 0, current_price)+++def fcfe_valuation(fcfe_projections: List[float], required_return: float, shares_outstanding: float,+ terminal_growth: float, current_price: float = None) -> ValuationResult:+ """Quick FCFE valuation"""+ model = FCFEModel()+ return model.calculate(fcfe_projections, required_return, shares_outstanding,+ terminal_growth, None, current_price)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dividend_models.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dividend_models.pynew file mode 100644index 000000000..a51016ee7--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/dividend_models.py@@ -0,0 +1,29 @@++Equity Investment Dividend Models Module+======================================++Dividend discount and income models++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/multiples_valuation.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/multiples_valuation.pynew file mode 100644index 000000000..031e0bfca--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/multiples_valuation.py@@ -0,0 +1,539 @@++Equity Investment Multiples Valuation Module+======================================++Relative valuation using multiples++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple, Union+from dataclasses import dataclass+import statistics+from scipy import stats++from fincept_terminal.Analytics.equityInvestment.base.base_models import (+ BaseValuationModel, CompanyData, MarketData, ValuationResult,+ ValuationMethod, CalculationEngine, ModelValidator, ValidationError+)+++@dataclass+class ComparableCompany:+ """Data structure for comparable company"""+ symbol: str+ name: str+ sector: str+ market_cap: float+ enterprise_value: float+ revenue: float+ ebitda: float+ net_income: float+ book_value: float+ current_price: float+ multiples: Dict[str, float]+++class PriceMultiplesModel(BaseValuationModel):+ """Price-based multiple valuation model"""++ def __init__(self):+ super().__init__("Price Multiples", "Price-based multiple valuation")+ self.valuation_method = ValuationMethod.MULTIPLES_PE++ def calculate_pe_ratio(self, price: float, eps: float) -> float:+ """Calculate Price-to-Earnings ratio"""+ if eps <= 0:+ raise ValidationError("Earnings per share must be positive for P/E calculation")+ return price / eps++ def calculate_pb_ratio(self, price: float, book_value_per_share: float) -> float:+ """Calculate Price-to-Book ratio"""+ if book_value_per_share <= 0:+ raise ValidationError("Book value per share must be positive for P/B calculation")+ return price / book_value_per_share++ def calculate_ps_ratio(self, price: float, sales_per_share: float) -> float:+ """Calculate Price-to-Sales ratio"""+ if sales_per_share <= 0:+ raise ValidationError("Sales per share must be positive for P/S calculation")+ return price / sales_per_share++ def calculate_peg_ratio(self, pe_ratio: float, growth_rate: float) -> float:+ """Calculate PEG ratio"""+ if growth_rate <= 0:+ raise ValidationError("Growth rate must be positive for PEG calculation")+ return pe_ratio / (growth_rate * 100) # Convert growth to percentage++ def calculate_dividend_yield(self, dividend_per_share: float, price: float) -> float:+ """Calculate dividend yield"""+ if price <= 0:+ raise ValidationError("Price must be positive for dividend yield calculation")+ return dividend_per_share / price++ def calculate_earnings_yield(self, eps: float, price: float) -> float:+ """Calculate earnings yield (E/P ratio)"""+ if price <= 0:+ raise ValidationError("Price must be positive for earnings yield calculation")+ return eps / price++ def normalize_earnings(self, earnings_history: List[float], method: str = "average") -> float:+ """Normalize earnings using various methods"""+ if not earnings_history:+ raise ValidationError("Earnings history cannot be empty")++ # Remove negative or zero earnings for certain methods+ positive_earnings = [e for e in earnings_history if e > 0]++ if method == "average":+ return statistics.mean(earnings_history)+ elif method == "median":+ return statistics.median(earnings_history)+ elif method == "average_positive":+ return statistics.mean(positive_earnings) if positive_earnings else 0+ elif method == "peak_earnings":+ return max(earnings_history)+ elif method == "trough_earnings":+ return min(positive_earnings) if positive_earnings else 0+ else:+ raise ValidationError(f"Unknown normalization method: {method}")++ def calculate_justified_pe_from_fundamentals(self, payout_ratio: float, required_return: float,+ growth_rate: float, is_leading: bool = True) -> float:+ """Calculate justified P/E ratio from fundamentals"""+ justified_pe = CalculationEngine.pe_ratio_from_fundamentals(payout_ratio, required_return, growth_rate)++ if not is_leading:+ # Convert to trailing P/E+ justified_pe = justified_pe / (1 + growth_rate)++ return justified_pe++ def calculate_justified_pb_from_fundamentals(self, roe: float, required_return: float,+ growth_rate: float) -> float:+ """Calculate justified P/B ratio from fundamentals"""+ if required_return <= growth_rate:+ raise ValidationError("Required return must be greater than growth rate")++ return (roe - growth_rate) / (required_return - growth_rate)++ def calculate_justified_ps_from_fundamentals(self, profit_margin: float, payout_ratio: float,+ required_return: float, growth_rate: float) -> float:+ """Calculate justified P/S ratio from fundamentals"""+ justified_pe = self.calculate_justified_pe_from_fundamentals(payout_ratio, required_return, growth_rate)+ return justified_pe * profit_margin++ def value_using_pe_multiple(self, comparable_pe: float, target_eps: float) -> float:+ """Value company using P/E multiple"""+ return comparable_pe * target_eps++ def value_using_pb_multiple(self, comparable_pb: float, target_bvps: float) -> float:+ """Value company using P/B multiple"""+ return comparable_pb * target_bvps++ def value_using_ps_multiple(self, comparable_ps: float, target_sps: float) -> float:+ """Value company using P/S multiple"""+ return comparable_ps * target_sps+++class EnterpriseValueMultiplesModel(BaseValuationModel):+ """Enterprise Value multiple valuation model"""++ def __init__(self):+ super().__init__("EV Multiples", "Enterprise value multiple valuation")+ self.valuation_method = ValuationMethod.MULTIPLES_EV_EBITDA++ def calculate_enterprise_value(self, market_cap: float, total_debt: float,+ cash: float, preferred_stock: float = 0) -> float:+ """Calculate Enterprise Value"""+ return market_cap + total_debt - cash + preferred_stock++ def calculate_ev_ebitda(self, enterprise_value: float, ebitda: float) -> float:+ """Calculate EV/EBITDA multiple"""+ if ebitda <= 0:+ raise ValidationError("EBITDA must be positive for EV/EBITDA calculation")+ return enterprise_value / ebitda++ def calculate_ev_sales(self, enterprise_value: float, sales: float) -> float:+ """Calculate EV/Sales multiple"""+ if sales <= 0:+ raise ValidationError("Sales must be positive for EV/Sales calculation")+ return enterprise_value / sales++ def calculate_ev_ebit(self, enterprise_value: float, ebit: float) -> float:+ """Calculate EV/EBIT multiple"""+ if ebit <= 0:+ raise ValidationError("EBIT must be positive for EV/EBIT calculation")+ return enterprise_value / ebit++ def calculate_ev_fcf(self, enterprise_value: float, free_cash_flow: float) -> float:+ """Calculate EV/FCF multiple"""+ if free_cash_flow <= 0:+ raise ValidationError("Free cash flow must be positive for EV/FCF calculation")+ return enterprise_value / free_cash_flow++ def value_using_ev_multiple(self, comparable_ev_multiple: float, target_metric: float,+ target_debt: float, target_cash: float,+ target_shares: float, preferred_stock: float = 0) -> float:+ """Value company using EV multiple and convert to per-share value"""+ # Calculate implied enterprise value+ implied_ev = comparable_ev_multiple * target_metric++ # Convert to equity value+ equity_value = implied_ev - target_debt + target_cash - preferred_stock++ # Convert to per-share value+ return equity_value / target_shares if target_shares > 0 else 0+++class ComparablesAnalyzer:+ """Analyze and select comparable companies"""++ def __init__(self):+ self.price_model = PriceMultiplesModel()+ self.ev_model = EnterpriseValueMultiplesModel()++ def calculate_all_multiples(self, company_data: ComparableCompany) -> Dict[str, float]:+ """Calculate all relevant multiples for a company"""+ multiples = {}++ try:+ # Price multiples+ if company_data.net_income > 0:+ eps = company_data.net_income / (company_data.market_cap / company_data.current_price)+ multiples['pe_ratio'] = self.price_model.calculate_pe_ratio(company_data.current_price, eps)+ multiples['earnings_yield'] = self.price_model.calculate_earnings_yield(eps, company_data.current_price)++ if company_data.book_value > 0:+ bvps = company_data.book_value / (company_data.market_cap / company_data.current_price)+ multiples['pb_ratio'] = self.price_model.calculate_pb_ratio(company_data.current_price, bvps)++ if company_data.revenue > 0:+ sps = company_data.revenue / (company_data.market_cap / company_data.current_price)+ multiples['ps_ratio'] = self.price_model.calculate_ps_ratio(company_data.current_price, sps)++ # Enterprise value multiples+ if company_data.ebitda > 0:+ multiples['ev_ebitda'] = self.ev_model.calculate_ev_ebitda(company_data.enterprise_value,+ company_data.ebitda)++ if company_data.revenue > 0:+ multiples['ev_sales'] = self.ev_model.calculate_ev_sales(company_data.enterprise_value,+ company_data.revenue)++ except ValidationError:+ pass # Skip ratios that can't be calculated++ return multiples++ def screen_comparables(self, comparables: List[ComparableCompany],+ target_company: ComparableCompany,+ screening_criteria: Dict[str, Any]) -> List[ComparableCompany]:+ """Screen comparable companies based on criteria"""+ screened = []++ for comp in comparables:+ # Sector screening+ if screening_criteria.get('same_sector', True) and comp.sector != target_company.sector:+ continue++ # Size screening+ size_ratio_limit = screening_criteria.get('max_size_ratio', 10)+ size_ratio = max(comp.market_cap, target_company.market_cap) / min(comp.market_cap,+ target_company.market_cap)+ if size_ratio > size_ratio_limit:+ continue++ # Profitability screening+ min_roe = screening_criteria.get('min_roe', -0.5)+ comp_roe = comp.net_income / comp.book_value if comp.book_value > 0 else -1+ if comp_roe < min_roe:+ continue++ # Growth screening+ if 'min_growth' in screening_criteria:+ # Would need historical data for growth calculation+ pass++ screened.append(comp)++ return screened++ def calculate_multiple_statistics(self, comparables: List[ComparableCompany],+ multiple_type: str) -> Dict[str, float]:+ """Calculate statistics for a specific multiple across comparables"""++ multiples_values = []+ for comp in comparables:+ comp_multiples = self.calculate_all_multiples(comp)+ if multiple_type in comp_multiples and comp_multiples[multiple_type] > 0:+ multiples_values.append(comp_multiples[multiple_type])++ if not multiples_values:+ raise ValidationError(f"No valid {multiple_type} values found in comparables")++ return {+ 'mean': statistics.mean(multiples_values),+ 'median': statistics.median(multiples_values),+ 'harmonic_mean': statistics.harmonic_mean(multiples_values),+ 'weighted_harmonic_mean': self._calculate_weighted_harmonic_mean(multiples_values, comparables),+ 'min': min(multiples_values),+ 'max': max(multiples_values),+ 'std_dev': statistics.stdev(multiples_values) if len(multiples_values) > 1 else 0,+ 'count': len(multiples_values),+ 'values': multiples_values+ }++ def _calculate_weighted_harmonic_mean(self, multiples: List[float],+ comparables: List[ComparableCompany]) -> float:+ """Calculate weighted harmonic mean using market cap as weights"""+ # Simplified - would need proper weights based on the specific multiple+ weights = [comp.market_cap for comp in comparables[:len(multiples)]]+ total_weight = sum(weights)++ weighted_sum = sum(w / m for w, m in zip(weights, multiples))+ return total_weight / weighted_sum+++class CrossSectionalRegressionAnalyzer:+ """Cross-sectional regression analysis for multiples"""++ def predict_pe_ratio(self, fundamentals_data: pd.DataFrame,+ target_fundamentals: Dict[str, float]) -> Dict[str, Any]:+ """Predict P/E ratio using cross-sectional regression on fundamentals"""++ # Prepare regression variables+ X = fundamentals_data[['growth_rate', 'payout_ratio', 'beta', 'roe']].fillna(0)+ y = fundamentals_data['pe_ratio'].fillna(0)++ # Remove outliers (P/E > 50 or < 0)+ mask = (y > 0) & (y < 50)+ X = X[mask]+ y = y[mask]++ if len(X) < 3:+ raise ValidationError("Insufficient data for regression analysis")++ # Perform regression+ from sklearn.linear_model import LinearRegression+ from sklearn.metrics import r2_score++ model = LinearRegression()+ model.fit(X, y)++ # Predict for target company+ target_X = np.array([[+ target_fundamentals.get('growth_rate', 0),+ target_fundamentals.get('payout_ratio', 0),+ target_fundamentals.get('beta', 1),+ target_fundamentals.get('roe', 0)+ ]])++ predicted_pe = model.predict(target_X)[0]++ # Calculate regression statistics+ y_pred = model.predict(X)+ r_squared = r2_score(y, y_pred)++ return {+ 'predicted_pe': predicted_pe,+ 'coefficients': dict(zip(['growth_rate', 'payout_ratio', 'beta', 'roe'], model.coef_)),+ 'intercept': model.intercept_,+ 'r_squared': r_squared,+ 'sample_size': len(X),+ 'target_fundamentals': target_fundamentals+ }+++class MultiplesValuationSuite:+ """Comprehensive multiples valuation analysis"""++ def __init__(self):+ self.price_model = PriceMultiplesModel()+ self.ev_model = EnterpriseValueMultiplesModel()+ self.comparables_analyzer = ComparablesAnalyzer()+ self.regression_analyzer = CrossSectionalRegressionAnalyzer()++ def comprehensive_multiples_valuation(self, target_company: CompanyData,+ comparables: List[ComparableCompany],+ multiples_to_use: List[str] = None) -> Dict[str, ValuationResult]:+ """Perform comprehensive multiples valuation"""++ if multiples_to_use is None:+ multiples_to_use = ['pe_ratio', 'pb_ratio', 'ps_ratio', 'ev_ebitda', 'ev_sales']++ results = {}++ # Convert target company to comparable format+ target_comparable = self._convert_to_comparable(target_company)++ for multiple_type in multiples_to_use:+ try:+ # Calculate multiple statistics+ stats = self.comparables_analyzer.calculate_multiple_statistics(comparables, multiple_type)++ # Use median as the representative multiple (most robust)+ representative_multiple = stats['median']++ # Calculate valuation based on multiple type+ if multiple_type in ['pe_ratio', 'pb_ratio', 'ps_ratio']:+ intrinsic_value = self._calculate_price_multiple_value(+ target_company, multiple_type, representative_multiple+ )+ else: # EV multiples+ intrinsic_value = self._calculate_ev_multiple_value(+ target_company, multiple_type, representative_multiple+ )++ # Create valuation result+ assumptions = {+ 'multiple_type': multiple_type,+ 'representative_multiple': representative_multiple,+ 'comparables_count': stats['count'],+ 'multiple_range': f"{stats['min']:.2f} - {stats['max']:.2f}",+ 'multiple_std_dev': stats['std_dev'],+ 'method': 'Median of Comparables'+ }++ calculation_details = {+ 'multiple_statistics': stats,+ 'target_metric': self._get_target_metric(target_company, multiple_type),+ 'calculation': f"{representative_multiple:.2f} × {self._get_target_metric(target_company, multiple_type):.2f}"+ }++ recommendation = self.price_model.generate_recommendation(intrinsic_value, target_company.current_price)+ upside_downside = self.price_model.calculate_upside_downside(intrinsic_value,+ target_company.current_price)++ results[multiple_type] = ValuationResult(+ method=ValuationMethod.MULTIPLES_PE, # Generic multiples method+ intrinsic_value=intrinsic_value,+ current_price=target_company.current_price,+ recommendation=recommendation,+ upside_downside=upside_downside,+ confidence_level="MEDIUM",+ assumptions=assumptions,+ calculation_details=calculation_details+ )++ except Exception as e:+ results[multiple_type] = f"Error: {str(e)}"++ return results++ def _convert_to_comparable(self, company_data: CompanyData) -> ComparableCompany:+ """Convert CompanyData to ComparableCompany format"""+ financial_data = company_data.financial_data++ return ComparableCompany(+ symbol=company_data.symbol,+ name=company_data.name,+ sector=company_data.sector,+ market_cap=company_data.market_cap,+ enterprise_value=self.ev_model.calculate_enterprise_value(+ company_data.market_cap,+ financial_data.get('total_debt', 0),+ financial_data.get('cash', 0)+ ),+ revenue=financial_data.get('revenue', 0),+ ebitda=financial_data.get('ebitda', 0),+ net_income=financial_data.get('net_income', 0),+ book_value=financial_data.get('book_value', 0) * company_data.shares_outstanding,+ current_price=company_data.current_price,+ multiples={}+ )++ def _calculate_price_multiple_value(self, company_data: CompanyData,+ multiple_type: str, multiple_value: float) -> float:+ """Calculate value using price multiples"""+ financial_data = company_data.financial_data+ shares = company_data.shares_outstanding++ if multiple_type == 'pe_ratio':+ eps = financial_data.get('earnings_per_share', 0)+ return self.price_model.value_using_pe_multiple(multiple_value, eps)++ elif multiple_type == 'pb_ratio':+ book_value_total = financial_data.get('book_value', 0) * shares+ bvps = book_value_total / shares if shares > 0 else 0+ return self.price_model.value_using_pb_multiple(multiple_value, bvps)++ elif multiple_type == 'ps_ratio':+ revenue = financial_data.get('revenue', 0)+ sps = revenue / shares if shares > 0 else 0+ return self.price_model.value_using_ps_multiple(multiple_value, sps)++ else:+ raise ValidationError(f"Unknown price multiple type: {multiple_type}")++ def _calculate_ev_multiple_value(self, company_data: CompanyData,+ multiple_type: str, multiple_value: float) -> float:+ """Calculate value using EV multiples"""+ financial_data = company_data.financial_data++ if multiple_type == 'ev_ebitda':+ target_metric = financial_data.get('ebitda', 0)+ elif multiple_type == 'ev_sales':+ target_metric = financial_data.get('revenue', 0)+ else:+ raise ValidationError(f"Unknown EV multiple type: {multiple_type}")++ return self.ev_model.value_using_ev_multiple(+ multiple_value, target_metric,+ financial_data.get('total_debt', 0),+ financial_data.get('cash', 0),+ company_data.shares_outstanding+ )++ def _get_target_metric(self, company_data: CompanyData, multiple_type: str) -> float:+ """Get the target metric value for multiple calculation"""+ financial_data = company_data.financial_data++ if multiple_type == 'pe_ratio':+ return financial_data.get('earnings_per_share', 0)+ elif multiple_type == 'pb_ratio':+ return financial_data.get('book_value', 0)+ elif multiple_type == 'ps_ratio':+ return financial_data.get('revenue', 0) / company_data.shares_outstanding+ elif multiple_type == 'ev_ebitda':+ return financial_data.get('ebitda', 0)+ elif multiple_type == 'ev_sales':+ return financial_data.get('revenue', 0)+ else:+ return 0+++# Convenience functions+def pe_multiple_valuation(target_eps: float, comparable_pe: float) -> float:+ """Quick P/E multiple valuation"""+ model = PriceMultiplesModel()+ return model.value_using_pe_multiple(comparable_pe, target_eps)+++def ev_ebitda_valuation(target_ebitda: float, comparable_ev_ebitda: float,+ debt: float, cash: float, shares: float) -> float:+ """Quick EV/EBITDA valuation"""+ model = EnterpriseValueMultiplesModel()+ return model.value_using_ev_multiple(comparable_ev_ebitda, target_ebitda, debt, cash, shares)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/private_valuation.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/private_valuation.pynew file mode 100644index 000000000..95d42e9dc--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/private_valuation.py@@ -0,0 +1,1348 @@++Equity Investment Private Valuation Module+======================================++Private company valuation methods++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple+from dataclasses import dataclass+from enum import Enum+import warnings++from .base_models import (+ BaseValuationModel, CompanyData, MarketData, ValuationResult,+ ValuationMethod, CalculationEngine, ModelValidator, ValidationError+)+++class ValuationApproach(Enum):+ """Private company valuation approaches"""+ INCOME_APPROACH = "income_approach"+ MARKET_APPROACH = "market_approach"+ ASSET_APPROACH = "asset_approach"+++class DiscountPremiumType(Enum):+ """Types of discounts and premiums"""+ MARKETABILITY_DISCOUNT = "marketability_discount"+ CONTROL_PREMIUM = "control_premium"+ MINORITY_DISCOUNT = "minority_discount"+ KEY_PERSON_DISCOUNT = "key_person_discount"+ SIZE_DISCOUNT = "size_discount"+++@dataclass+class PrivateCompanyData:+ """Private company specific data structure"""+ company_name: str+ industry: str+ annual_revenue: float+ ebitda: float+ net_income: float+ book_value: float+ total_assets: float+ total_debt: float+ working_capital: float+ capex: float+ employee_count: int+ years_in_business: int+ ownership_structure: Dict[str, float]+ key_person_dependency: str # "High", "Medium", "Low"+ management_quality: str # "Strong", "Average", "Weak"+ financial_reporting_quality: str # "Audited", "Reviewed", "Compiled"+++@dataclass+class MarketableSecurityData:+ """Comparable public company data"""+ symbol: str+ market_cap: float+ enterprise_value: float+ revenue: float+ ebitda: float+ net_income: float+ price_multiples: Dict[str, float]+++@dataclass+class PrivateTransaction:+ """Private company transaction data"""+ transaction_date: str+ target_company: str+ buyer_type: str # "Strategic", "Financial"+ transaction_value: float+ revenue: float+ ebitda: float+ transaction_multiples: Dict[str, float]+ control_transaction: bool+++class PrivateCompanyNormalizer:+ """Normalize private company financials for valuation"""++ def __init__(self):+ self.normalization_categories = [+ 'owner_compensation',+ 'related_party_transactions',+ 'non_recurring_items',+ 'non_operating_income',+ 'discretionary_expenses'+ ]++ def normalize_earnings(self, reported_earnings: float,+ adjustments: Dict[str, float]) -> Dict[str, float]:+ """Normalize earnings for valuation purposes"""++ normalized_earnings = reported_earnings+ adjustment_details = {}++ # Owner compensation normalization+ if 'excess_owner_compensation' in adjustments:+ excess_comp = adjustments['excess_owner_compensation']+ normalized_earnings += excess_comp+ adjustment_details['owner_compensation_addback'] = excess_comp++ # Related party adjustments+ if 'related_party_expense_adjustment' in adjustments:+ rp_adj = adjustments['related_party_expense_adjustment']+ normalized_earnings += rp_adj+ adjustment_details['related_party_adjustment'] = rp_adj++ # Non-recurring items+ if 'non_recurring_expenses' in adjustments:+ nr_exp = adjustments['non_recurring_expenses']+ normalized_earnings += nr_exp+ adjustment_details['non_recurring_addback'] = nr_exp++ if 'non_recurring_income' in adjustments:+ nr_inc = adjustments['non_recurring_income']+ normalized_earnings -= nr_inc+ adjustment_details['non_recurring_deduction'] = -nr_inc++ # Discretionary expenses+ if 'discretionary_expenses' in adjustments:+ disc_exp = adjustments['discretionary_expenses']+ normalized_earnings += disc_exp+ adjustment_details['discretionary_addback'] = disc_exp++ # Personal expenses+ if 'personal_expenses' in adjustments:+ pers_exp = adjustments['personal_expenses']+ normalized_earnings += pers_exp+ adjustment_details['personal_expense_addback'] = pers_exp++ return {+ 'normalized_earnings': normalized_earnings,+ 'reported_earnings': reported_earnings,+ 'total_adjustments': normalized_earnings - reported_earnings,+ 'adjustment_details': adjustment_details+ }++ def normalize_balance_sheet(self, assets: Dict[str, float],+ liabilities: Dict[str, float]) -> Dict[str, Any]:+ """Normalize balance sheet items"""++ normalized_assets = assets.copy()+ normalized_liabilities = liabilities.copy()+ adjustments = []++ # Asset adjustments+ # Remove personal assets+ if 'personal_assets' in normalized_assets:+ personal_assets = normalized_assets.pop('personal_assets')+ adjustments.append(f"Removed personal assets: ${personal_assets:,.0f}")++ # Adjust asset values to fair value+ if 'real_estate_book_value' in assets and 'real_estate_market_value' in assets:+ book_value = assets['real_estate_book_value']+ market_value = assets['real_estate_market_value']+ if market_value != book_value:+ normalized_assets['real_estate'] = market_value+ adjustments.append(f"Real estate marked to market: ${market_value - book_value:+,.0f}")++ # Liability adjustments+ # Remove personal liabilities+ if 'personal_liabilities' in normalized_liabilities:+ personal_liabs = normalized_liabilities.pop('personal_liabilities')+ adjustments.append(f"Removed personal liabilities: ${personal_liabs:,.0f}")++ total_normalized_assets = sum(normalized_assets.values())+ total_normalized_liabilities = sum(normalized_liabilities.values())+ normalized_equity = total_normalized_assets - total_normalized_liabilities++ return {+ 'normalized_assets': normalized_assets,+ 'normalized_liabilities': normalized_liabilities,+ 'normalized_equity': normalized_equity,+ 'total_assets': total_normalized_assets,+ 'total_liabilities': total_normalized_liabilities,+ 'adjustments': adjustments+ }+++class IncomeApproachValuator(BaseValuationModel):+ """Income approach valuation for private companies"""++ def __init__(self):+ super().__init__("Income Approach", "Income-based private company valuation")+ self.valuation_method = ValuationMethod.PRIVATE_INCOME++ def validate_inputs(self, **kwargs) -> bool:+ """Validate income approach inputs"""+ normalized_earnings = kwargs.get('normalized_earnings')+ discount_rate = kwargs.get('discount_rate')++ if normalized_earnings is None or discount_rate is None:+ raise ValidationError("Normalized earnings and discount rate required")++ ModelValidator.validate_percentage(discount_rate, "Discount rate")+ return True++ def calculate_capitalized_earnings_value(self, normalized_earnings: float,+ capitalization_rate: float,+ growth_rate: float = 0) -> float:+ """Calculate value using capitalized earnings method"""++ if capitalization_rate <= growth_rate:+ raise ValidationError("Capitalization rate must be greater than growth rate")++ if growth_rate == 0:+ # No growth capitalization+ return normalized_earnings / capitalization_rate+ else:+ # Gordon growth model for private companies+ next_year_earnings = normalized_earnings * (1 + growth_rate)+ return next_year_earnings / (capitalization_rate - growth_rate)++ def calculate_dcf_value(self, projected_cash_flows: List[float],+ discount_rate: float, terminal_value: float = None,+ terminal_growth: float = None) -> Dict[str, float]:+ """Calculate DCF value for private company"""++ # Present value of projected cash flows+ pv_cash_flows = 0+ for i, cf in enumerate(projected_cash_flows):+ pv_cf = CalculationEngine.present_value(cf, discount_rate, i + 1)+ pv_cash_flows += pv_cf++ # Terminal value+ if terminal_value is None and terminal_growth is not None:+ if len(projected_cash_flows) > 0:+ final_cf = projected_cash_flows[-1]+ terminal_cf = final_cf * (1 + terminal_growth)+ terminal_value = terminal_cf / (discount_rate - terminal_growth)+ else:+ terminal_value = 0+ elif terminal_value is None:+ terminal_value = 0++ # Present value of terminal value+ pv_terminal = CalculationEngine.present_value(terminal_value, discount_rate, len(projected_cash_flows))++ # Total enterprise value+ enterprise_value = pv_cash_flows + pv_terminal++ return {+ 'pv_cash_flows': pv_cash_flows,+ 'terminal_value': terminal_value,+ 'pv_terminal': pv_terminal,+ 'enterprise_value': enterprise_value+ }++ def calculate_excess_earnings_value(self, normalized_earnings: float,+ tangible_assets: float, required_return_assets: float,+ required_return_intangibles: float) -> Dict[str, float]:+ """Calculate value using excess earnings method"""++ # Return attributable to tangible assets+ tangible_asset_return = tangible_assets * required_return_assets++ # Excess earnings (attributable to intangible assets)+ excess_earnings = normalized_earnings - tangible_asset_return++ # Value of intangible assets+ if excess_earnings > 0:+ intangible_value = excess_earnings / required_return_intangibles+ else:+ intangible_value = 0++ # Total business value+ total_value = tangible_assets + intangible_value++ return {+ 'tangible_asset_value': tangible_assets,+ 'tangible_asset_return': tangible_asset_return,+ 'excess_earnings': excess_earnings,+ 'intangible_value': intangible_value,+ 'total_business_value': total_value+ }++ def calculate_adjusted_present_value(self, unlevered_cash_flows: List[float],+ unlevered_discount_rate: float,+ tax_shield_values: List[float],+ tax_shield_discount_rate: float) -> Dict[str, float]:+ """Calculate APV for private companies with complex capital structures"""++ # Present value of unlevered cash flows+ pv_unlevered_cf = sum(+ CalculationEngine.present_value(cf, unlevered_discount_rate, i + 1)+ for i, cf in enumerate(unlevered_cash_flows)+ )++ # Present value of tax shields+ pv_tax_shields = sum(+ CalculationEngine.present_value(ts, tax_shield_discount_rate, i + 1)+ for i, ts in enumerate(tax_shield_values)+ )++ # Total firm value+ total_firm_value = pv_unlevered_cf + pv_tax_shields++ return {+ 'unlevered_firm_value': pv_unlevered_cf,+ 'tax_shield_value': pv_tax_shields,+ 'total_firm_value': total_firm_value+ }+++class MarketApproachValuator(BaseValuationModel):+ """Market approach valuation for private companies"""++ def __init__(self):+ super().__init__("Market Approach", "Market-based private company valuation")+ self.valuation_method = ValuationMethod.PRIVATE_MARKET++ def validate_inputs(self, **kwargs) -> bool:+ """Validate market approach inputs"""+ return True++ def calculate_guideline_public_company_value(self, private_company_metrics: Dict[str, float],+ public_comparables: List[MarketableSecurityData],+ control_premium: float = 0) -> Dict[str, Any]:+ """Calculate value using guideline public company method"""++ if not public_comparables:+ raise ValidationError("At least one public comparable required")++ valuation_multiples = {}++ # Calculate multiples for each comparable+ for comp in public_comparables:+ comp_multiples = {}++ # Revenue multiple+ if comp.revenue > 0:+ comp_multiples['ev_revenue'] = comp.enterprise_value / comp.revenue+ comp_multiples['price_revenue'] = comp.market_cap / comp.revenue++ # EBITDA multiple+ if comp.ebitda > 0:+ comp_multiples['ev_ebitda'] = comp.enterprise_value / comp.ebitda++ # Earnings multiple+ if comp.net_income > 0:+ comp_multiples['price_earnings'] = comp.market_cap / comp.net_income++ valuation_multiples[comp.symbol] = comp_multiples++ # Calculate median multiples+ median_multiples = {}+ for multiple_type in ['ev_revenue', 'ev_ebitda', 'price_earnings', 'price_revenue']:+ values = []+ for comp_multiples in valuation_multiples.values():+ if multiple_type in comp_multiples:+ values.append(comp_multiples[multiple_type])++ if values:+ median_multiples[multiple_type] = np.median(values)++ # Apply multiples to private company+ indicated_values = {}++ if 'ev_revenue' in median_multiples and 'revenue' in private_company_metrics:+ ev = median_multiples['ev_revenue'] * private_company_metrics['revenue']+ indicated_values['ev_revenue_method'] = ev++ if 'ev_ebitda' in median_multiples and 'ebitda' in private_company_metrics:+ ev = median_multiples['ev_ebitda'] * private_company_metrics['ebitda']+ indicated_values['ev_ebitda_method'] = ev++ if 'price_earnings' in median_multiples and 'net_income' in private_company_metrics:+ equity_value = median_multiples['price_earnings'] * private_company_metrics['net_income']+ indicated_values['price_earnings_method'] = equity_value++ # Apply control premium if applicable+ if control_premium > 0:+ for method, value in indicated_values.items():+ indicated_values[f"{method}_with_control_premium"] = value * (1 + control_premium)++ return {+ 'comparable_multiples': valuation_multiples,+ 'median_multiples': median_multiples,+ 'indicated_values': indicated_values,+ 'control_premium_applied': control_premium+ }++ def calculate_guideline_transaction_value(self, private_company_metrics: Dict[str, float],+ transaction_comparables: List[PrivateTransaction]) -> Dict[str, Any]:+ """Calculate value using guideline transaction method"""++ if not transaction_comparables:+ raise ValidationError("At least one transaction comparable required")++ transaction_multiples = {}++ # Calculate multiples for each transaction+ for i, txn in enumerate(transaction_comparables):+ txn_multiples = {}++ # Revenue multiple+ if txn.revenue > 0:+ txn_multiples['transaction_revenue'] = txn.transaction_value / txn.revenue++ # EBITDA multiple+ if txn.ebitda > 0:+ txn_multiples['transaction_ebitda'] = txn.transaction_value / txn.ebitda++ transaction_multiples[f"transaction_{i + 1}"] = txn_multiples++ # Calculate median transaction multiples+ median_txn_multiples = {}+ for multiple_type in ['transaction_revenue', 'transaction_ebitda']:+ values = []+ for txn_multiples in transaction_multiples.values():+ if multiple_type in txn_multiples:+ values.append(txn_multiples[multiple_type])++ if values:+ median_txn_multiples[multiple_type] = np.median(values)++ # Apply to private company+ indicated_values = {}++ if 'transaction_revenue' in median_txn_multiples and 'revenue' in private_company_metrics:+ value = median_txn_multiples['transaction_revenue'] * private_company_metrics['revenue']+ indicated_values['transaction_revenue_method'] = value++ if 'transaction_ebitda' in median_txn_multiples and 'ebitda' in private_company_metrics:+ value = median_txn_multiples['transaction_ebitda'] * private_company_metrics['ebitda']+ indicated_values['transaction_ebitda_method'] = value++ return {+ 'transaction_multiples': transaction_multiples,+ 'median_transaction_multiples': median_txn_multiples,+ 'indicated_values': indicated_values+ }+++class AssetApproachValuator(BaseValuationModel):+ """Asset approach valuation for private companies"""++ def __init__(self):+ super().__init__("Asset Approach", "Asset-based private company valuation")+ self.valuation_method = ValuationMethod.PRIVATE_ASSET++ def validate_inputs(self, **kwargs) -> bool:+ """Validate asset approach inputs"""+ return True++ def calculate_adjusted_book_value(self, book_values: Dict[str, float],+ fair_value_adjustments: Dict[str, float]) -> Dict[str, float]:+ """Calculate adjusted book value method"""++ adjusted_asset_values = {}+ total_adjustments = 0++ for asset, book_value in book_values.items():+ if asset in fair_value_adjustments:+ fair_value_adj = fair_value_adjustments[asset]+ adjusted_value = book_value + fair_value_adj+ total_adjustments += fair_value_adj+ else:+ adjusted_value = book_value++ adjusted_asset_values[asset] = adjusted_value++ # Calculate total adjusted book value+ total_adjusted_book_value = sum(adjusted_asset_values.values())+ total_book_value = sum(book_values.values())++ return {+ 'original_book_value': total_book_value,+ 'total_adjustments': total_adjustments,+ 'adjusted_book_value': total_adjusted_book_value,+ 'asset_adjustments': {asset: adjusted_asset_values[asset] - book_values.get(asset, 0)+ for asset in adjusted_asset_values}+ }++ def calculate_replacement_cost_value(self, asset_categories: Dict[str, Dict[str, float]]) -> Dict[str, float]:+ """Calculate replacement cost of assets"""++ replacement_costs = {}+ total_replacement_cost = 0++ for category, assets in asset_categories.items():+ category_cost = 0++ for asset, params in assets.items():+ original_cost = params.get('original_cost', 0)+ current_age = params.get('current_age', 0)+ useful_life = params.get('useful_life', 10)+ inflation_factor = params.get('inflation_factor', 1.0)++ # Calculate replacement cost new+ replacement_cost_new = original_cost * inflation_factor++ # Calculate depreciation+ if useful_life > 0:+ depreciation_rate = current_age / useful_life+ depreciation_rate = min(depreciation_rate, 1.0) # Cap at 100%+ else:+ depreciation_rate = 0++ # Net replacement cost+ net_replacement_cost = replacement_cost_new * (1 - depreciation_rate)++ category_cost += net_replacement_cost++ replacement_costs[category] = category_cost+ total_replacement_cost += category_cost++ return {+ 'category_costs': replacement_costs,+ 'total_replacement_cost': total_replacement_cost+ }++ def calculate_liquidation_value(self, assets: Dict[str, float],+ liquidation_discounts: Dict[str, float],+ liquidation_costs: float = 0) -> Dict[str, float]:+ """Calculate liquidation value of assets"""++ liquidation_values = {}+ total_liquidation_value = 0++ for asset, book_value in assets.items():+ discount = liquidation_discounts.get(asset, 0.5) # Default 50% discount+ liquidation_value = book_value * (1 - discount)+ liquidation_values[asset] = liquidation_value+ total_liquidation_value += liquidation_value++ # Subtract liquidation costs+ net_liquidation_value = total_liquidation_value - liquidation_costs++ return {+ 'gross_liquidation_value': total_liquidation_value,+ 'liquidation_costs': liquidation_costs,+ 'net_liquidation_value': net_liquidation_value,+ 'asset_liquidation_values': liquidation_values+ }+++class DiscountPremiumAnalyzer:+ """Analyze discounts and premiums for private company valuations"""++ def __init__(self):+ # Typical discount/premium ranges based on empirical studies+ self.typical_ranges = {+ 'marketability_discount': (0.20, 0.40), # 20-40%+ 'control_premium': (0.20, 0.35), # 20-35%+ 'minority_discount': (0.10, 0.25), # 10-25%+ 'key_person_discount': (0.05, 0.20), # 5-20%+ 'size_discount': (0.05, 0.15) # 5-15%+ }++ def calculate_marketability_discount(self, company_characteristics: Dict[str, Any]) -> Dict[str, float]:+ """Calculate discount for lack of marketability (DLOM)"""++ base_discount = 0.25 # Base 25% discount++ # Adjustments based on company characteristics+ adjustments = 0++ # Financial performance+ profitability = company_characteristics.get('profitability', 'Average')+ if profitability == 'Strong':+ adjustments -= 0.05+ elif profitability == 'Weak':+ adjustments += 0.10++ # Size+ revenue = company_characteristics.get('revenue', 0)+ if revenue > 100_000_000: # >$100M+ adjustments -= 0.05+ elif revenue < 10_000_000: # <$10M+ adjustments += 0.05++ # Financial reporting quality+ reporting_quality = company_characteristics.get('financial_reporting_quality', 'Compiled')+ if reporting_quality == 'Audited':+ adjustments -= 0.05+ elif reporting_quality == 'Compiled':+ adjustments += 0.05++ # Growth prospects+ growth_prospects = company_characteristics.get('growth_prospects', 'Average')+ if growth_prospects == 'High':+ adjustments -= 0.05+ elif growth_prospects == 'Low':+ adjustments += 0.05++ # Management quality+ management_quality = company_characteristics.get('management_quality', 'Average')+ if management_quality == 'Strong':+ adjustments -= 0.03+ elif management_quality == 'Weak':+ adjustments += 0.07++ final_discount = max(0.10, min(0.50, base_discount + adjustments)) # Cap between 10-50%++ return {+ 'base_discount': base_discount,+ 'total_adjustments': adjustments,+ 'final_marketability_discount': final_discount,+ 'discount_range': self.typical_ranges['marketability_discount']+ }++ def calculate_control_premium(self, ownership_percentage: float,+ control_characteristics: Dict[str, Any]) -> Dict[str, float]:+ """Calculate control premium or minority discount"""++ if ownership_percentage >= 0.50:+ # Control position - calculate control premium+ base_premium = 0.25 # Base 25% premium++ # Adjustments+ adjustments = 0++ # Level of control+ if ownership_percentage >= 0.75:+ adjustments += 0.05 # Strong control+ elif ownership_percentage < 0.60:+ adjustments -= 0.05 # Weak control++ # Synergy potential+ synergy_potential = control_characteristics.get('synergy_potential', 'Medium')+ if synergy_potential == 'High':+ adjustments += 0.10+ elif synergy_potential == 'Low':+ adjustments -= 0.05++ # Strategic value+ strategic_value = control_characteristics.get('strategic_value', 'Medium')+ if strategic_value == 'High':+ adjustments += 0.05++ final_premium = max(0.10, min(0.50, base_premium + adjustments))++ return {+ 'control_premium': final_premium,+ 'ownership_percentage': ownership_percentage,+ 'control_level': 'Control',+ 'adjustments': adjustments+ }++ else:+ # Minority position - calculate minority discount+ base_discount = 0.15 # Base 15% discount++ # Adjustments based on rights+ adjustments = 0++ # Voting rights+ voting_rights = control_characteristics.get('voting_rights', 'Proportional')+ if voting_rights == 'Enhanced':+ adjustments -= 0.05+ elif voting_rights == 'Limited':+ adjustments += 0.05++ # Liquidity provisions+ liquidity_provisions = control_characteristics.get('liquidity_provisions', False)+ if liquidity_provisions:+ adjustments -= 0.03++ # Tag-along rights+ tag_along_rights = control_characteristics.get('tag_along_rights', False)+ if tag_along_rights:+ adjustments -= 0.02++ final_discount = max(0.05, min(0.30, base_discount + adjustments))++ return {+ 'minority_discount': final_discount,+ 'ownership_percentage': ownership_percentage,+ 'control_level': 'Minority',+ 'adjustments': adjustments+ }++ def calculate_key_person_discount(self, key_person_characteristics: Dict[str, Any]) -> Dict[str, float]:+ """Calculate discount for key person dependency"""++ dependency_level = key_person_characteristics.get('dependency_level', 'Medium')++ base_discounts = {+ 'High': 0.15,+ 'Medium': 0.08,+ 'Low': 0.03+ }++ base_discount = base_discounts.get(dependency_level, 0.08)++ # Adjustments+ adjustments = 0++ # Age of key person+ age = key_person_characteristics.get('age', 50)+ if age > 65:+ adjustments += 0.05+ elif age < 40:+ adjustments -= 0.02++ # Succession planning+ succession_plan = key_person_characteristics.get('succession_plan', False)+ if succession_plan:+ adjustments -= 0.05+ else:+ adjustments += 0.03++ # Contract terms+ employment_contract = key_person_characteristics.get('employment_contract', False)+ if employment_contract:+ adjustments -= 0.02++ # Non-compete agreement+ non_compete = key_person_characteristics.get('non_compete', False)+ if non_compete:+ adjustments -= 0.02++ final_discount = max(0, min(0.25, base_discount + adjustments))++ return {+ 'base_discount': base_discount,+ 'adjustments': adjustments,+ 'final_key_person_discount': final_discount,+ 'dependency_level': dependency_level+ }++ def calculate_size_discount(self, company_size_metrics: Dict[str, float]) -> Dict[str, float]:+ """Calculate size-related discount"""++ revenue = company_size_metrics.get('revenue', 0)+ assets = company_size_metrics.get('total_assets', 0)+ employees = company_size_metrics.get('employee_count', 0)++ # Size-based discount schedule+ if revenue > 1_000_000_000: # >$1B+ size_discount = 0.02+ elif revenue > 100_000_000: # $100M-$1B+ size_discount = 0.05+ elif revenue > 25_000_000: # $25M-$100M+ size_discount = 0.08+ elif revenue > 5_000_000: # $5M-$25M+ size_discount = 0.12+ else: # <$5M+ size_discount = 0.15++ return {+ 'size_discount': size_discount,+ 'revenue': revenue,+ 'size_category': self.categorize_company_size(revenue)+ }++ def categorize_company_size(self, revenue: float) -> str:+ """Categorize company by size"""+ if revenue > 1_000_000_000:+ return "Large"+ elif revenue > 100_000_000:+ return "Medium-Large"+ elif revenue > 25_000_000:+ return "Medium"+ elif revenue > 5_000_000:+ return "Small-Medium"+ else:+ return "Small"++ def apply_all_discounts_premiums(self, base_value: float,+ discount_premium_factors: Dict[str, float]) -> Dict[str, float]:+ """Apply multiple discounts and premiums to base value"""++ adjusted_value = base_value+ cumulative_adjustment = 0++ # Apply control premium first (if applicable)+ if 'control_premium' in discount_premium_factors:+ control_premium = discount_premium_factors['control_premium']+ adjusted_value *= (1 + control_premium)+ cumulative_adjustment += control_premium++ # Apply minority discount (if applicable, mutually exclusive with control premium)+ elif 'minority_discount' in discount_premium_factors:+ minority_discount = discount_premium_factors['minority_discount']+ adjusted_value *= (1 - minority_discount)+ cumulative_adjustment -= minority_discount++ # Apply marketability discount+ if 'marketability_discount' in discount_premium_factors:+ marketability_discount = discount_premium_factors['marketability_discount']+ adjusted_value *= (1 - marketability_discount)+ cumulative_adjustment -= marketability_discount++ # Apply key person discount+ if 'key_person_discount' in discount_premium_factors:+ key_person_discount = discount_premium_factors['key_person_discount']+ adjusted_value *= (1 - key_person_discount)+ cumulative_adjustment -= key_person_discount++ # Apply size discount+ if 'size_discount' in discount_premium_factors:+ size_discount = discount_premium_factors['size_discount']+ adjusted_value *= (1 - size_discount)+ cumulative_adjustment -= size_discount++ return {+ 'base_value': base_value,+ 'adjusted_value': adjusted_value,+ 'total_adjustment_percentage': cumulative_adjustment,+ 'individual_adjustments': discount_premium_factors+ }+++class PrivateCompanyValuator:+ """Comprehensive private company valuation framework"""++ def __init__(self):+ self.normalizer = PrivateCompanyNormalizer()+ self.income_valuator = IncomeApproachValuator()+ self.market_valuator = MarketApproachValuator()+ self.asset_valuator = AssetApproachValuator()+ self.discount_analyzer = DiscountPremiumAnalyzer()++ def comprehensive_valuation(self, private_company: PrivateCompanyData,+ valuation_inputs: Dict[str, Any]) -> Dict[str, Any]:+ """Perform comprehensive private company valuation"""++ # Step 1: Normalize financials+ earnings_adjustments = valuation_inputs.get('earnings_adjustments', {})+ normalized_earnings = self.normalizer.normalize_earnings(+ private_company.net_income, earnings_adjustments+ )++ # Step 2: Income Approach Valuations+ income_valuations = self.perform_income_approach_valuations(+ private_company, normalized_earnings, valuation_inputs+ )++ # Step 3: Market Approach Valuations+ market_valuations = self.perform_market_approach_valuations(+ private_company, valuation_inputs+ )++ # Step 4: Asset Approach Valuations+ asset_valuations = self.perform_asset_approach_valuations(+ private_company, valuation_inputs+ )++ # Step 5: Calculate Discounts and Premiums+ discounts_premiums = self.calculate_discounts_premiums(+ private_company, valuation_inputs+ )++ # Step 6: Synthesize Results+ final_valuation = self.synthesize_valuation_results(+ income_valuations, market_valuations, asset_valuations, discounts_premiums+ )++ return {+ 'normalized_earnings': normalized_earnings,+ 'income_approach': income_valuations,+ 'market_approach': market_valuations,+ 'asset_approach': asset_valuations,+ 'discounts_premiums': discounts_premiums,+ 'final_valuation': final_valuation,+ 'valuation_summary': self.generate_valuation_summary(final_valuation)+ }++ def perform_income_approach_valuations(self, company: PrivateCompanyData,+ normalized_earnings: Dict[str, float],+ inputs: Dict[str, Any]) -> Dict[str, Any]:+ """Perform all income approach valuations"""++ income_valuations = {}++ # Capitalized Earnings Method+ cap_rate = inputs.get('capitalization_rate', 0.20)+ growth_rate = inputs.get('growth_rate', 0.03)++ try:+ cap_earnings_value = self.income_valuator.calculate_capitalized_earnings_value(+ normalized_earnings['normalized_earnings'], cap_rate, growth_rate+ )+ income_valuations['capitalized_earnings'] = {+ 'value': cap_earnings_value,+ 'method': 'Capitalized Earnings',+ 'cap_rate': cap_rate,+ 'growth_rate': growth_rate+ }+ except Exception as e:+ income_valuations['capitalized_earnings'] = {'error': str(e)}++ # DCF Method+ if 'projected_cash_flows' in inputs:+ discount_rate = inputs.get('discount_rate', 0.15)+ terminal_growth = inputs.get('terminal_growth', 0.03)++ try:+ dcf_value = self.income_valuator.calculate_dcf_value(+ inputs['projected_cash_flows'], discount_rate, None, terminal_growth+ )+ income_valuations['dcf'] = {+ **dcf_value,+ 'method': 'Discounted Cash Flow',+ 'discount_rate': discount_rate,+ 'terminal_growth': terminal_growth+ }+ except Exception as e:+ income_valuations['dcf'] = {'error': str(e)}++ # Excess Earnings Method+ if 'tangible_assets' in inputs:+ tangible_assets = inputs['tangible_assets']+ asset_return_rate = inputs.get('asset_return_rate', 0.08)+ intangible_return_rate = inputs.get('intangible_return_rate', 0.15)++ try:+ excess_earnings_value = self.income_valuator.calculate_excess_earnings_value(+ normalized_earnings['normalized_earnings'], tangible_assets,+ asset_return_rate, intangible_return_rate+ )+ income_valuations['excess_earnings'] = {+ **excess_earnings_value,+ 'method': 'Excess Earnings'+ }+ except Exception as e:+ income_valuations['excess_earnings'] = {'error': str(e)}++ return income_valuations++ def perform_market_approach_valuations(self, company: PrivateCompanyData,+ inputs: Dict[str, Any]) -> Dict[str, Any]:+ """Perform market approach valuations"""++ market_valuations = {}++ # Company metrics for multiple application+ company_metrics = {+ 'revenue': company.annual_revenue,+ 'ebitda': company.ebitda,+ 'net_income': company.net_income+ }++ # Guideline Public Company Method+ if 'public_comparables' in inputs:+ control_premium = inputs.get('control_premium', 0)++ try:+ gpc_value = self.market_valuator.calculate_guideline_public_company_value(+ company_metrics, inputs['public_comparables'], control_premium+ )+ market_valuations['guideline_public_companies'] = {+ **gpc_value,+ 'method': 'Guideline Public Companies'+ }+ except Exception as e:+ market_valuations['guideline_public_companies'] = {'error': str(e)}++ # Guideline Transaction Method+ if 'transaction_comparables' in inputs:+ try:+ transaction_value = self.market_valuator.calculate_guideline_transaction_value(+ company_metrics, inputs['transaction_comparables']+ )+ market_valuations['guideline_transactions'] = {+ **transaction_value,+ 'method': 'Guideline Transactions'+ }+ except Exception as e:+ market_valuations['guideline_transactions'] = {'error': str(e)}++ return market_valuations++ def perform_asset_approach_valuations(self, company: PrivateCompanyData,+ inputs: Dict[str, Any]) -> Dict[str, Any]:+ """Perform asset approach valuations"""++ asset_valuations = {}++ # Adjusted Book Value Method+ if 'asset_fair_values' in inputs:+ book_values = {+ 'current_assets': company.total_assets * 0.4, # Simplified+ 'fixed_assets': company.total_assets * 0.6+ }++ try:+ adjusted_bv = self.asset_valuator.calculate_adjusted_book_value(+ book_values, inputs['asset_fair_values']+ )+ asset_valuations['adjusted_book_value'] = {+ **adjusted_bv,+ 'method': 'Adjusted Book Value'+ }+ except Exception as e:+ asset_valuations['adjusted_book_value'] = {'error': str(e)}++ # Replacement Cost Method+ if 'asset_categories' in inputs:+ try:+ replacement_cost = self.asset_valuator.calculate_replacement_cost_value(+ inputs['asset_categories']+ )+ asset_valuations['replacement_cost'] = {+ **replacement_cost,+ 'method': 'Replacement Cost'+ }+ except Exception as e:+ asset_valuations['replacement_cost'] = {'error': str(e)}++ # Liquidation Value Method+ if 'liquidation_assumptions' in inputs:+ assets = {'total_assets': company.total_assets}+ liquidation_discounts = inputs['liquidation_assumptions'].get('discounts', {})+ liquidation_costs = inputs['liquidation_assumptions'].get('costs', 0)++ try:+ liquidation_value = self.asset_valuator.calculate_liquidation_value(+ assets, liquidation_discounts, liquidation_costs+ )+ asset_valuations['liquidation_value'] = {+ **liquidation_value,+ 'method': 'Liquidation Value'+ }+ except Exception as e:+ asset_valuations['liquidation_value'] = {'error': str(e)}++ return asset_valuations++ def calculate_discounts_premiums(self, company: PrivateCompanyData,+ inputs: Dict[str, Any]) -> Dict[str, Any]:+ """Calculate all applicable discounts and premiums"""++ discounts_premiums = {}++ # Company characteristics for discount analysis+ characteristics = {+ 'revenue': company.annual_revenue,+ 'profitability': self.assess_profitability_level(company),+ 'financial_reporting_quality': company.financial_reporting_quality,+ 'growth_prospects': inputs.get('growth_prospects', 'Average'),+ 'management_quality': company.management_quality+ }++ # Marketability Discount+ marketability_discount = self.discount_analyzer.calculate_marketability_discount(characteristics)+ discounts_premiums['marketability'] = marketability_discount++ # Control Premium/Minority Discount+ ownership_percentage = inputs.get('ownership_percentage', 1.0)+ control_characteristics = inputs.get('control_characteristics', {})++ control_analysis = self.discount_analyzer.calculate_control_premium(+ ownership_percentage, control_characteristics+ )+ discounts_premiums['control'] = control_analysis++ # Key Person Discount+ key_person_chars = {+ 'dependency_level': company.key_person_dependency,+ 'age': inputs.get('key_person_age', 50),+ 'succession_plan': inputs.get('succession_plan', False),+ 'employment_contract': inputs.get('employment_contract', False),+ 'non_compete': inputs.get('non_compete', False)+ }++ key_person_discount = self.discount_analyzer.calculate_key_person_discount(key_person_chars)+ discounts_premiums['key_person'] = key_person_discount++ # Size Discount+ size_metrics = {+ 'revenue': company.annual_revenue,+ 'total_assets': company.total_assets,+ 'employee_count': company.employee_count+ }++ size_discount = self.discount_analyzer.calculate_size_discount(size_metrics)+ discounts_premiums['size'] = size_discount++ return discounts_premiums++ def assess_profitability_level(self, company: PrivateCompanyData) -> str:+ """Assess company profitability level"""++ if company.annual_revenue == 0:+ return 'Weak'++ ebitda_margin = company.ebitda / company.annual_revenue+ net_margin = company.net_income / company.annual_revenue++ if ebitda_margin > 0.20 and net_margin > 0.10:+ return 'Strong'+ elif ebitda_margin > 0.10 and net_margin > 0.05:+ return 'Average'+ else:+ return 'Weak'++ def synthesize_valuation_results(self, income_results: Dict, market_results: Dict,+ asset_results: Dict, discounts_premiums: Dict) -> Dict[str, Any]:+ """Synthesize results from all valuation approaches"""++ # Collect all valid valuation indications+ valuation_indications = []+ method_weights = {}++ # Income approach values+ for method, result in income_results.items():+ if 'error' not in result:+ if method == 'capitalized_earnings':+ value = result['value']+ weight = 0.4 # Higher weight for income approach+ elif method == 'dcf':+ value = result['enterprise_value']+ weight = 0.4+ elif method == 'excess_earnings':+ value = result['total_business_value']+ weight = 0.3+ else:+ continue++ valuation_indications.append(value)+ method_weights[f"income_{method}"] = weight++ # Market approach values+ for method, result in market_results.items():+ if 'error' not in result and 'indicated_values' in result:+ # Use median of indicated values from market approach+ indicated_values = list(result['indicated_values'].values())+ if indicated_values:+ value = np.median(indicated_values)+ weight = 0.5 # High weight for market approach+ valuation_indications.append(value)+ method_weights[f"market_{method}"] = weight++ # Asset approach values (typically lower weight unless asset-heavy business)+ for method, result in asset_results.items():+ if 'error' not in result:+ if method == 'adjusted_book_value':+ value = result['adjusted_book_value']+ weight = 0.2+ elif method == 'replacement_cost':+ value = result['total_replacement_cost']+ weight = 0.2+ elif method == 'liquidation_value':+ value = result['net_liquidation_value']+ weight = 0.1 # Lowest weight+ else:+ continue++ valuation_indications.append(value)+ method_weights[f"asset_{method}"] = weight++ # Calculate weighted average if multiple methods available+ if len(valuation_indications) > 1:+ weights = list(method_weights.values())+ total_weight = sum(weights)+ normalized_weights = [w / total_weight for w in weights]++ weighted_value = sum(v * w for v, w in zip(valuation_indications, normalized_weights))+ simple_average = np.mean(valuation_indications)+ median_value = np.median(valuation_indications)+ else:+ weighted_value = valuation_indications[0] if valuation_indications else 0+ simple_average = weighted_value+ median_value = weighted_value++ # Apply discounts and premiums to base valuation+ base_value = weighted_value++ # Compile discount/premium factors+ dp_factors = {}++ if 'control' in discounts_premiums:+ control_result = discounts_premiums['control']+ if 'control_premium' in control_result:+ dp_factors['control_premium'] = control_result['control_premium']+ elif 'minority_discount' in control_result:+ dp_factors['minority_discount'] = control_result['minority_discount']++ if 'marketability' in discounts_premiums:+ dp_factors['marketability_discount'] = discounts_premiums['marketability']['final_marketability_discount']++ if 'key_person' in discounts_premiums:+ dp_factors['key_person_discount'] = discounts_premiums['key_person']['final_key_person_discount']++ if 'size' in discounts_premiums:+ dp_factors['size_discount'] = discounts_premiums['size']['size_discount']++ # Apply discounts and premiums+ final_adjustment = self.discount_analyzer.apply_all_discounts_premiums(base_value, dp_factors)++ return {+ 'valuation_indications': valuation_indications,+ 'method_weights': method_weights,+ 'base_valuation': {+ 'weighted_average': weighted_value,+ 'simple_average': simple_average,+ 'median': median_value+ },+ 'discount_premium_analysis': final_adjustment,+ 'final_valuation_range': {+ 'low': final_adjustment['adjusted_value'] * 0.85,+ 'mid': final_adjustment['adjusted_value'],+ 'high': final_adjustment['adjusted_value'] * 1.15+ },+ 'valuation_methods_used': len(valuation_indications)+ }++ def generate_valuation_summary(self, final_valuation: Dict[str, Any]) -> Dict[str, Any]:+ """Generate executive summary of valuation"""++ final_value = final_valuation['final_valuation_range']['mid']+ base_value = final_valuation['base_valuation']['weighted_average']++ total_adjustment = final_valuation['discount_premium_analysis']['total_adjustment_percentage']++ summary = {+ 'final_value': final_value,+ 'valuation_range': final_valuation['final_valuation_range'],+ 'base_value_before_adjustments': base_value,+ 'total_discount_premium_adjustment': total_adjustment,+ 'number_of_methods_used': final_valuation['valuation_methods_used'],+ 'primary_valuation_driver': self.identify_primary_driver(final_valuation),+ 'confidence_level': self.assess_confidence_level(final_valuation),+ 'key_assumptions': self.extract_key_assumptions(final_valuation)+ }++ return summary++ def identify_primary_driver(self, final_valuation: Dict[str, Any]) -> str:+ """Identify primary valuation driver"""++ method_weights = final_valuation['method_weights']++ if not method_weights:+ return "No clear driver"++ max_weight_method = max(method_weights.items(), key=lambda x: x[1])[0]++ if 'income' in max_weight_method:+ return "Income/Earnings Generation"+ elif 'market' in max_weight_method:+ return "Market Comparables"+ elif 'asset' in max_weight_method:+ return "Asset Values"+ else:+ return "Multiple Factors"++ def assess_confidence_level(self, final_valuation: Dict[str, Any]) -> str:+ """Assess confidence level in valuation"""++ num_methods = final_valuation['valuation_methods_used']++ if num_methods >= 3:+ return "High"+ elif num_methods == 2:+ return "Medium"+ else:+ return "Low"++ def extract_key_assumptions(self, final_valuation: Dict[str, Any]) -> List[str]:+ """Extract key valuation assumptions"""++ assumptions = [+ "Normalized earnings reflect sustainable performance",+ "Market multiples are representative of subject company",+ "Discount rates reflect appropriate risk levels"+ ]++ # Add specific assumptions based on adjustments applied+ dp_analysis = final_valuation['discount_premium_analysis']+ individual_adjustments = dp_analysis['individual_adjustments']++ if 'marketability_discount' in individual_adjustments:+ assumptions.append("Marketability discount reflects lack of ready market")++ if 'control_premium' in individual_adjustments:+ assumptions.append("Control premium reflects strategic value")+ elif 'minority_discount' in individual_adjustments:+ assumptions.append("Minority discount reflects lack of control")++ if 'key_person_discount' in individual_adjustments:+ assumptions.append("Key person discount reflects dependency risk")++ return assumptions+++# Convenience functions for quick private company valuations+def quick_private_company_valuation(company_data: PrivateCompanyData,+ normalized_earnings: float,+ capitalization_rate: float = 0.20) -> float:+ """Quick private company valuation using capitalized earnings"""++ valuator = IncomeApproachValuator()+ return valuator.calculate_capitalized_earnings_value(normalized_earnings, capitalization_rate)+++def calculate_marketability_discount(revenue: float, profitability: str = "Average",+ reporting_quality: str = "Compiled") -> float:+ """Quick marketability discount calculation"""++ analyzer = DiscountPremiumAnalyzer()+ characteristics = {+ 'revenue': revenue,+ 'profitability': profitability,+ 'financial_reporting_quality': reporting_quality,+ 'growth_prospects': 'Average',+ 'management_quality': 'Average'+ }++ result = analyzer.calculate_marketability_discount(characteristics)+ return result['final_marketability_discount']+++def estimate_control_premium(ownership_percentage: float) -> float:+ """Quick control premium estimation"""++ analyzer = DiscountPremiumAnalyzer()+ control_chars = {'synergy_potential': 'Medium', 'strategic_value': 'Medium'}++ result = analyzer.calculate_control_premium(ownership_percentage, control_chars)++ if 'control_premium' in result:+ return result['control_premium']+ elif 'minority_discount' in result:+ return -result['minority_discount'] # Return negative for discount+ else:+ return 0\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/residual_income.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/residual_income.pynew file mode 100644index 000000000..5d0517cbc--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/equity_valuation/residual_income.py@@ -0,0 +1,476 @@++Equity Investment Residual Income Module+======================================++Residual income and economic value added models++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple+from dataclasses import dataclass+import math++from .base_models import (+ BaseValuationModel, CompanyData, MarketData, ValuationResult,+ ValuationMethod, CalculationEngine, ModelValidator, ValidationError+)+++@dataclass+class ResidualIncomeParameters:+ """Parameters for Residual Income calculations"""+ book_values: List[float]+ net_incomes: List[float]+ required_return: float+ terminal_roe: Optional[float] = None+ terminal_growth: Optional[float] = None+++class ResidualIncomeModel(BaseValuationModel):+ """Single-stage and Multi-stage Residual Income Model"""++ def __init__(self):+ super().__init__("Residual Income Model", "Residual income valuation")+ self.valuation_method = ValuationMethod.RESIDUAL_INCOME++ def calculate_residual_income(self, net_income: float, beginning_book_value: float,+ required_return: float) -> float:+ """Calculate residual income for a single period"""+ return CalculationEngine.residual_income(net_income, beginning_book_value, required_return)++ def calculate_continuing_residual_income(self, final_ri: float, required_return: float,+ growth_rate: float) -> float:+ """Calculate continuing residual income value"""+ if growth_rate >= required_return:+ raise ValidationError("Growth rate must be less than required return for continuing RI")++ # Continuing RI = RI_n+1 / (r - g)+ next_ri = final_ri * (1 + growth_rate)+ return next_ri / (required_return - growth_rate)++ def calculate_single_stage_ri_value(self, current_book_value: float, roe: float,+ required_return: float, growth_rate: float = 0) -> float:+ """Calculate single-stage constant growth RI value"""++ if growth_rate >= required_return:+ raise ValidationError("Growth rate must be less than required return")++ # Calculate next period's residual income+ next_net_income = current_book_value * roe * (1 + growth_rate)+ next_book_value = current_book_value * (1 + growth_rate)+ next_ri = self.calculate_residual_income(next_net_income, current_book_value, required_return)++ # Present value of all future RIs+ if growth_rate == 0:+ pv_future_ris = next_ri / required_return+ else:+ pv_future_ris = next_ri / (required_return - growth_rate)++ # Total value = Current BV + PV of future RIs+ return current_book_value + pv_future_ris++ def calculate_multistage_ri_value(self, current_book_value: float,+ projected_ris: List[float], required_return: float,+ terminal_ri: float = None, terminal_growth: float = None) -> Dict[str, float]:+ """Calculate multi-stage RI value"""++ # Present value of projected residual incomes+ pv_projected_ris = 0+ pv_details = []++ for year, ri in enumerate(projected_ris, 1):+ pv_ri = CalculationEngine.present_value(ri, required_return, year)+ pv_projected_ris += pv_ri+ pv_details.append({'year': year, 'ri': ri, 'pv_ri': pv_ri})++ # Terminal value+ if terminal_ri is not None:+ if terminal_growth is None:+ terminal_growth = 0++ continuing_ri_value = self.calculate_continuing_residual_income(+ terminal_ri, required_return, terminal_growth+ )+ pv_terminal = CalculationEngine.present_value(continuing_ri_value, required_return, len(projected_ris))+ else:+ pv_terminal = 0++ # Total value+ total_value = current_book_value + pv_projected_ris + pv_terminal++ return {+ 'current_book_value': current_book_value,+ 'pv_projected_ris': pv_projected_ris,+ 'pv_terminal': pv_terminal,+ 'total_value': total_value,+ 'pv_details': pv_details+ }++ def calculate_intrinsic_value(self, company_data: CompanyData, market_data: MarketData) -> float:+ """Calculate intrinsic value using RI model"""+ financial_data = company_data.financial_data++ book_value_total = financial_data.get('book_value', 0) * company_data.shares_outstanding+ roe = financial_data.get('roe', 0)+ required_return = market_data.required_return+ growth_rate = market_data.growth_rate++ total_value = self.calculate_single_stage_ri_value(book_value_total, roe, required_return, growth_rate)+ return total_value / company_data.shares_outstanding if company_data.shares_outstanding > 0 else 0++ def calculate(self, current_book_value: float, projected_ris: List[float],+ required_return: float, shares_outstanding: float,+ terminal_ri: float = None, terminal_growth: float = None,+ current_price: float = None) -> ValuationResult:+ """Calculate valuation using Residual Income model"""++ # Validate inputs+ ModelValidator.validate_positive_number(current_book_value, "Current book value")+ ModelValidator.validate_percentage(required_return, "Required return")++ if terminal_growth is not None:+ ModelValidator.validate_growth_vs_required_return(terminal_growth, required_return)++ # Calculate RI value+ ri_components = self.calculate_multistage_ri_value(+ current_book_value, projected_ris, required_return, terminal_ri, terminal_growth+ )++ # Per-share value+ intrinsic_value = ri_components['total_value'] / shares_outstanding if shares_outstanding > 0 else 0++ # Store assumptions+ assumptions = {+ 'current_book_value': current_book_value,+ 'required_return': required_return,+ 'terminal_growth_rate': terminal_growth,+ 'projection_periods': len(projected_ris),+ 'book_value_percentage': (current_book_value / ri_components['total_value']) * 100,+ 'terminal_value_percentage': (ri_components['pv_terminal'] / ri_components['total_value']) * 100,+ 'model_type': 'Multi-stage Residual Income Model'+ }++ # Detailed calculations+ calculation_details = {+ 'projected_ris': projected_ris,+ 'pv_projected_ris': ri_components['pv_projected_ris'],+ 'pv_terminal': ri_components['pv_terminal'],+ 'total_value': ri_components['total_value'],+ 'intrinsic_value_per_share': intrinsic_value,+ 'pv_details': ri_components['pv_details']+ }++ # Generate recommendation+ recommendation = "HOLD"+ upside_downside = 0+ if current_price:+ recommendation = self.generate_recommendation(intrinsic_value, current_price)+ upside_downside = self.calculate_upside_downside(intrinsic_value, current_price)++ return ValuationResult(+ method=self.valuation_method,+ intrinsic_value=intrinsic_value,+ current_price=current_price or 0,+ recommendation=recommendation,+ upside_downside=upside_downside,+ confidence_level="MEDIUM",+ assumptions=assumptions,+ calculation_details=calculation_details+ )+++class EconomicValueAddedModel(BaseValuationModel):+ """Economic Value Added (EVA) Model"""++ def __init__(self):+ super().__init__("EVA Model", "Economic Value Added valuation")+ self.valuation_method = ValuationMethod.RESIDUAL_INCOME++ def calculate_eva(self, nopat: float, invested_capital: float, wacc: float) -> float:+ """Calculate Economic Value Added"""+ return CalculationEngine.economic_value_added(nopat, invested_capital, wacc)++ def calculate_nopat(self, ebit: float, tax_rate: float) -> float:+ """Calculate Net Operating Profit After Tax"""+ return ebit * (1 - tax_rate)++ def calculate_invested_capital(self, total_assets: float, non_interest_bearing_liabilities: float) -> float:+ """Calculate invested capital"""+ return total_assets - non_interest_bearing_liabilities++ def calculate_eva_from_components(self, ebit: float, tax_rate: float, total_assets: float,+ non_interest_bearing_liabilities: float, wacc: float) -> float:+ """Calculate EVA from financial statement components"""+ nopat = self.calculate_nopat(ebit, tax_rate)+ invested_capital = self.calculate_invested_capital(total_assets, non_interest_bearing_liabilities)+ return self.calculate_eva(nopat, invested_capital, wacc)++ def calculate_market_value_added(self, market_value: float, invested_capital: float) -> float:+ """Calculate Market Value Added (MVA)"""+ return market_value - invested_capital++ def eva_valuation(self, current_invested_capital: float, projected_evas: List[float],+ wacc: float, terminal_eva: float = None, terminal_growth: float = None) -> Dict[str, float]:+ """Calculate firm value using EVA approach"""++ # Present value of projected EVAs+ pv_evas = 0+ for year, eva in enumerate(projected_evas, 1):+ pv_eva = CalculationEngine.present_value(eva, wacc, year)+ pv_evas += pv_eva++ # Terminal value of EVAs+ if terminal_eva is not None:+ if terminal_growth is None:+ terminal_growth = 0++ if terminal_growth >= wacc:+ raise ValidationError("Terminal growth must be less than WACC for EVA terminal value")++ next_eva = terminal_eva * (1 + terminal_growth)+ terminal_value = next_eva / (wacc - terminal_growth)+ pv_terminal = CalculationEngine.present_value(terminal_value, wacc, len(projected_evas))+ else:+ pv_terminal = 0++ # Total firm value = Invested Capital + PV of future EVAs+ firm_value = current_invested_capital + pv_evas + pv_terminal++ return {+ 'current_invested_capital': current_invested_capital,+ 'pv_projected_evas': pv_evas,+ 'pv_terminal_evas': pv_terminal,+ 'total_firm_value': firm_value+ }+++class ResidualIncomeAnalyzer:+ """Comprehensive Residual Income analysis tools"""++ def __init__(self):+ self.ri_model = ResidualIncomeModel()+ self.eva_model = EconomicValueAddedModel()++ def calculate_implied_growth_rate(self, current_price: float, current_book_value_per_share: float,+ roe: float, required_return: float) -> float:+ """Calculate implied growth rate from current market P/B ratio"""++ pb_ratio = current_price / current_book_value_per_share++ # From RI model: P/B = 1 + (ROE - r) / (r - g)+ # Solving for g: g = r - (ROE - r) / (P/B - 1)++ if pb_ratio <= 1:+ raise ValidationError("P/B ratio must be greater than 1 for growth calculation")++ implied_growth = required_return - (roe - required_return) / (pb_ratio - 1)+ return implied_growth++ def calculate_fundamental_pb_ratio(self, roe: float, required_return: float,+ growth_rate: float) -> float:+ """Calculate justified P/B ratio from fundamentals"""+ if required_return <= growth_rate:+ raise ValidationError("Required return must be greater than growth rate")++ # P/B = 1 + (ROE - r) / (r - g)+ return 1 + (roe - required_return) / (required_return - growth_rate)++ def analyze_roe_sustainability(self, historical_roe: List[float],+ industry_avg_roe: float) -> Dict[str, Any]:+ """Analyze ROE sustainability and mean reversion"""++ if not historical_roe:+ raise ValidationError("Historical ROE data required")++ current_roe = historical_roe[-1]+ avg_roe = np.mean(historical_roe)+ roe_volatility = np.std(historical_roe) if len(historical_roe) > 1 else 0++ # Mean reversion analysis+ roe_trend = np.polyfit(range(len(historical_roe)), historical_roe, 1)[0]++ # Sustainability assessment+ sustainability_score = "HIGH"+ warnings = []++ if current_roe > 0.25: # 25% ROE+ sustainability_score = "LOW"+ warnings.append("ROE above 25% typically not sustainable long-term")++ if abs(current_roe - industry_avg_roe) > 0.1: # 10% difference+ warnings.append("ROE significantly different from industry average")++ if roe_volatility > 0.05: # 5% volatility+ warnings.append("High ROE volatility indicates uncertainty")++ return {+ 'current_roe': current_roe,+ 'average_roe': avg_roe,+ 'industry_avg_roe': industry_avg_roe,+ 'roe_volatility': roe_volatility,+ 'roe_trend': roe_trend,+ 'sustainability_score': sustainability_score,+ 'warnings': warnings+ }++ def forecast_residual_income(self, current_book_value: float, projected_roes: List[float],+ required_return: float, payout_ratios: List[float] = None) -> List[float]:+ """Forecast residual income based on ROE and growth assumptions"""++ if payout_ratios is None:+ payout_ratios = [0.4] * len(projected_roes) # 40% default payout ratio++ if len(payout_ratios) != len(projected_roes):+ raise ValidationError("Payout ratios and ROEs must have same length")++ projected_ris = []+ book_value = current_book_value++ for i, (roe, payout_ratio) in enumerate(zip(projected_roes, payout_ratios)):+ # Calculate net income+ net_income = book_value * roe++ # Calculate residual income+ ri = self.ri_model.calculate_residual_income(net_income, book_value, required_return)+ projected_ris.append(ri)++ # Update book value for next period+ retention_ratio = 1 - payout_ratio+ book_value *= (1 + roe * retention_ratio)++ return projected_ris++ def compare_ri_with_other_models(self, company_data: CompanyData, market_data: MarketData,+ ddm_value: float = None, dcf_value: float = None) -> Dict[str, Any]:+ """Compare RI valuation with DDM and DCF models"""++ # Calculate RI value+ ri_value = self.ri_model.calculate_intrinsic_value(company_data, market_data)++ comparison = {+ 'ri_value': ri_value,+ 'current_price': company_data.current_price+ }++ if ddm_value:+ comparison['ddm_value'] = ddm_value+ comparison['ri_vs_ddm_diff'] = (ri_value - ddm_value) / ddm_value * 100++ if dcf_value:+ comparison['dcf_value'] = dcf_value+ comparison['ri_vs_dcf_diff'] = (ri_value - dcf_value) / dcf_value * 100++ # Value recognition analysis+ book_value_per_share = (company_data.financial_data.get('book_value', 0) *+ company_data.shares_outstanding) / company_data.shares_outstanding++ comparison['book_value_per_share'] = book_value_per_share+ comparison['market_to_book'] = company_data.current_price / book_value_per_share+ comparison['ri_to_book'] = ri_value / book_value_per_share++ return comparison++ def accounting_quality_assessment(self, financial_statements: Dict[str, pd.DataFrame]) -> Dict[str, Any]:+ """Assess accounting quality for RI model reliability"""++ income_stmt = financial_statements.get('income_statement', pd.DataFrame())+ balance_sheet = financial_statements.get('balance_sheet', pd.DataFrame())++ quality_issues = []+ quality_score = 100 # Start with perfect score++ if income_stmt.empty or balance_sheet.empty:+ return {'quality_score': 0, 'issues': ['Financial statements not available']}++ try:+ # Check for aggressive revenue recognition+ revenue_growth = income_stmt['revenue'].pct_change().iloc[-1] if 'revenue' in income_stmt.columns else 0+ receivables_growth = balance_sheet['accounts_receivable'].pct_change().iloc[+ -1] if 'accounts_receivable' in balance_sheet.columns else 0++ if abs(receivables_growth) > abs(revenue_growth) * 1.5:+ quality_issues.append("Receivables growing much faster than revenue")+ quality_score -= 20++ # Check for inventory issues+ if 'inventory' in balance_sheet.columns and 'cost_of_goods_sold' in income_stmt.columns:+ inventory_turnover = income_stmt['cost_of_goods_sold'].iloc[-1] / balance_sheet['inventory'].iloc[-1]+ if inventory_turnover < 2: # Very low turnover+ quality_issues.append("Low inventory turnover may indicate obsolete inventory")+ quality_score -= 15++ # Check for excessive goodwill+ if 'goodwill' in balance_sheet.columns and 'total_assets' in balance_sheet.columns:+ goodwill_ratio = balance_sheet['goodwill'].iloc[-1] / balance_sheet['total_assets'].iloc[-1]+ if goodwill_ratio > 0.3: # More than 30% goodwill+ quality_issues.append("High goodwill percentage increases impairment risk")+ quality_score -= 10++ # Check for debt structure+ if 'total_debt' in balance_sheet.columns and 'total_equity' in balance_sheet.columns:+ debt_to_equity = balance_sheet['total_debt'].iloc[-1] / balance_sheet['total_equity'].iloc[-1]+ if debt_to_equity > 2: # High leverage+ quality_issues.append("High leverage may distort ROE calculations")+ quality_score -= 10++ except Exception as e:+ quality_issues.append(f"Error in accounting quality assessment: {str(e)}")+ quality_score -= 30++ return {+ 'quality_score': max(0, quality_score),+ 'issues': quality_issues,+ 'recommendations': [+ "Verify revenue recognition policies",+ "Check for off-balance-sheet items",+ "Analyze working capital components",+ "Review goodwill and intangible assets"+ ]+ }+++# Convenience functions+def single_stage_ri_valuation(current_book_value: float, roe: float, required_return: float,+ growth_rate: float, shares_outstanding: float) -> float:+ """Quick single-stage RI valuation"""+ model = ResidualIncomeModel()+ total_value = model.calculate_single_stage_ri_value(current_book_value, roe, required_return, growth_rate)+ return total_value / shares_outstanding+++def eva_firm_valuation(current_invested_capital: float, projected_evas: List[float],+ wacc: float, terminal_growth: float = 0) -> float:+ """Quick EVA firm valuation"""+ model = EconomicValueAddedModel()+ terminal_eva = projected_evas[-1] if projected_evas else 0+ components = model.eva_valuation(current_invested_capital, projected_evas, wacc, terminal_eva, terminal_growth)+ return components['total_firm_value']+++def calculate_justified_pb_ratio(roe: float, required_return: float, growth_rate: float) -> float:+ """Quick justified P/B ratio calculation"""+ analyzer = ResidualIncomeAnalyzer()+ return analyzer.calculate_fundamental_pb_ratio(roe, required_return, growth_rate)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/index_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/index_analysis.pynew file mode 100644index 000000000..503ffe7f6--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/index_analysis.py@@ -0,0 +1,627 @@++Equity Investment Index Analysis Module+======================================++Market index and benchmark analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple, Union+from dataclasses import dataclass+from enum import Enum+import math++from .base_models import (+ BaseMarketAnalysisModel, ValidationError, FinceptAnalyticsError+)+++class IndexWeightingMethod(Enum):+ """Index weighting methodologies"""+ PRICE_WEIGHTED = "price_weighted"+ MARKET_CAP_WEIGHTED = "market_cap_weighted"+ EQUAL_WEIGHTED = "equal_weighted"+ FUNDAMENTAL_WEIGHTED = "fundamental_weighted"+ FLOAT_ADJUSTED = "float_adjusted"+++class IndexType(Enum):+ """Types of market indexes"""+ EQUITY = "equity"+ FIXED_INCOME = "fixed_income"+ COMMODITY = "commodity"+ ALTERNATIVE = "alternative"+ MULTI_ASSET = "multi_asset"+++@dataclass+class IndexConstituent:+ """Individual component of an index"""+ symbol: str+ name: str+ shares_outstanding: float+ float_shares: float+ current_price: float+ market_cap: float+ weight: float+ sector: str+++@dataclass+class IndexPerformance:+ """Index performance metrics"""+ index_value: float+ price_return: float+ total_return: float+ dividend_yield: float+ volatility: float+ period_start: str+ period_end: str+++class IndexConstructor:+ """Index construction and management framework"""++ def __init__(self, name: str, weighting_method: IndexWeightingMethod):+ self.name = name+ self.weighting_method = weighting_method+ self.constituents = []+ self.base_value = 1000 # Default base index value+ self.base_date = None+ self.divisor = 1.0++ def add_constituent(self, constituent: IndexConstituent):+ """Add a constituent to the index"""+ self.constituents.append(constituent)++ def remove_constituent(self, symbol: str):+ """Remove a constituent from the index"""+ self.constituents = [c for c in self.constituents if c.symbol != symbol]++ def calculate_weights(self) -> Dict[str, float]:+ """Calculate weights based on weighting methodology"""++ if not self.constituents:+ return {}++ weights = {}++ if self.weighting_method == IndexWeightingMethod.PRICE_WEIGHTED:+ # Weight by price+ total_price = sum(c.current_price for c in self.constituents)+ for constituent in self.constituents:+ weights[constituent.symbol] = constituent.current_price / total_price++ elif self.weighting_method == IndexWeightingMethod.MARKET_CAP_WEIGHTED:+ # Weight by market capitalization+ total_market_cap = sum(c.market_cap for c in self.constituents)+ for constituent in self.constituents:+ weights[constituent.symbol] = constituent.market_cap / total_market_cap++ elif self.weighting_method == IndexWeightingMethod.EQUAL_WEIGHTED:+ # Equal weight for all constituents+ equal_weight = 1.0 / len(self.constituents)+ for constituent in self.constituents:+ weights[constituent.symbol] = equal_weight++ elif self.weighting_method == IndexWeightingMethod.FLOAT_ADJUSTED:+ # Weight by float-adjusted market cap+ total_float_cap = sum(c.float_shares * c.current_price for c in self.constituents)+ for constituent in self.constituents:+ float_cap = constituent.float_shares * constituent.current_price+ weights[constituent.symbol] = float_cap / total_float_cap++ elif self.weighting_method == IndexWeightingMethod.FUNDAMENTAL_WEIGHTED:+ # Weight by fundamental metrics (simplified: using market cap as proxy)+ total_fundamental = sum(c.market_cap for c in self.constituents)+ for constituent in self.constituents:+ weights[constituent.symbol] = constituent.market_cap / total_fundamental++ return weights++ def calculate_index_value(self, prices: Dict[str, float], base_prices: Dict[str, float] = None) -> float:+ """Calculate current index value"""++ if not self.constituents:+ return self.base_value++ if base_prices is None:+ base_prices = {c.symbol: c.current_price for c in self.constituents}++ if self.weighting_method == IndexWeightingMethod.PRICE_WEIGHTED:+ return self._calculate_price_weighted_value(prices, base_prices)+ elif self.weighting_method in [IndexWeightingMethod.MARKET_CAP_WEIGHTED,+ IndexWeightingMethod.FLOAT_ADJUSTED]:+ return self._calculate_cap_weighted_value(prices, base_prices)+ elif self.weighting_method == IndexWeightingMethod.EQUAL_WEIGHTED:+ return self._calculate_equal_weighted_value(prices, base_prices)+ else:+ return self._calculate_cap_weighted_value(prices, base_prices) # Default++ def _calculate_price_weighted_value(self, prices: Dict[str, float],+ base_prices: Dict[str, float]) -> float:+ """Calculate price-weighted index value"""+ current_sum = sum(prices.get(c.symbol, c.current_price) for c in self.constituents)+ base_sum = sum(base_prices.get(c.symbol, c.current_price) for c in self.constituents)++ return self.base_value * (current_sum / base_sum) / self.divisor++ def _calculate_cap_weighted_value(self, prices: Dict[str, float],+ base_prices: Dict[str, float]) -> float:+ """Calculate market cap weighted index value"""+ current_cap = 0+ base_cap = 0++ for constituent in self.constituents:+ shares = (constituent.float_shares if self.weighting_method == IndexWeightingMethod.FLOAT_ADJUSTED+ else constituent.shares_outstanding)++ current_price = prices.get(constituent.symbol, constituent.current_price)+ base_price = base_prices.get(constituent.symbol, constituent.current_price)++ current_cap += shares * current_price+ base_cap += shares * base_price++ return self.base_value * (current_cap / base_cap) if base_cap > 0 else self.base_value++ def _calculate_equal_weighted_value(self, prices: Dict[str, float],+ base_prices: Dict[str, float]) -> float:+ """Calculate equal-weighted index value"""+ returns = []++ for constituent in self.constituents:+ current_price = prices.get(constituent.symbol, constituent.current_price)+ base_price = base_prices.get(constituent.symbol, constituent.current_price)++ if base_price > 0:+ returns.append(current_price / base_price)++ if returns:+ avg_return = np.mean(returns)+ return self.base_value * avg_return+ else:+ return self.base_value+++class IndexCalculator:+ """Calculate index returns and performance metrics"""++ @staticmethod+ def calculate_price_return(current_value: float, previous_value: float) -> float:+ """Calculate price return"""+ if previous_value <= 0:+ raise ValidationError("Previous value must be positive")+ return (current_value - previous_value) / previous_value++ @staticmethod+ def calculate_total_return(current_value: float, previous_value: float,+ dividend_income: float) -> float:+ """Calculate total return including dividends"""+ if previous_value <= 0:+ raise ValidationError("Previous value must be positive")+ return ((current_value - previous_value) + dividend_income) / previous_value++ @staticmethod+ def calculate_index_dividend_yield(constituents: List[IndexConstituent],+ weights: Dict[str, float],+ dividend_yields: Dict[str, float]) -> float:+ """Calculate weighted average dividend yield"""+ total_yield = 0++ for constituent in constituents:+ weight = weights.get(constituent.symbol, 0)+ div_yield = dividend_yields.get(constituent.symbol, 0)+ total_yield += weight * div_yield++ return total_yield++ @staticmethod+ def calculate_index_volatility(returns: pd.Series, annualize: bool = True) -> float:+ """Calculate index volatility"""+ volatility = returns.std()+ if annualize:+ # Annualize assuming daily returns+ volatility *= np.sqrt(252)+ return volatility++ @staticmethod+ def calculate_tracking_error(index_returns: pd.Series, benchmark_returns: pd.Series) -> float:+ """Calculate tracking error between index and benchmark"""+ if len(index_returns) != len(benchmark_returns):+ raise ValidationError("Return series must have same length")++ excess_returns = index_returns - benchmark_returns+ return excess_returns.std() * np.sqrt(252) # Annualized+++class IndexRebalancer:+ """Handle index rebalancing and reconstitution"""++ def __init__(self, index_constructor: IndexConstructor):+ self.index_constructor = index_constructor+ self.rebalancing_frequency = "quarterly" # monthly, quarterly, annually+ self.last_rebalance_date = None++ def needs_rebalancing(self, current_date: str, weights: Dict[str, float],+ tolerance: float = 0.05) -> bool:+ """Determine if index needs rebalancing"""++ # Check weight drift+ target_weights = self.index_constructor.calculate_weights()++ for symbol in weights:+ if symbol in target_weights:+ weight_drift = abs(weights[symbol] - target_weights[symbol])+ if weight_drift > tolerance:+ return True++ return False++ def rebalance_index(self, new_prices: Dict[str, float],+ target_weights: Dict[str, float] = None) -> Dict[str, Any]:+ """Perform index rebalancing"""++ if target_weights is None:+ target_weights = self.index_constructor.calculate_weights()++ # Update constituent prices+ for constituent in self.index_constructor.constituents:+ if constituent.symbol in new_prices:+ constituent.current_price = new_prices[constituent.symbol]+ constituent.market_cap = constituent.shares_outstanding * constituent.current_price++ # Recalculate weights+ new_weights = self.index_constructor.calculate_weights()++ # Calculate rebalancing adjustments+ adjustments = {}+ for symbol in target_weights:+ if symbol in new_weights:+ adjustments[symbol] = target_weights[symbol] - new_weights[symbol]++ return {+ 'new_weights': new_weights,+ 'target_weights': target_weights,+ 'adjustments': adjustments,+ 'rebalancing_date': self.last_rebalance_date+ }++ def reconstitute_index(self, additions: List[IndexConstituent] = None,+ deletions: List[str] = None) -> Dict[str, Any]:+ """Perform index reconstitution (adding/removing constituents)"""++ changes = {+ 'additions': [],+ 'deletions': [],+ 'before_count': len(self.index_constructor.constituents),+ 'after_count': 0+ }++ # Remove constituents+ if deletions:+ for symbol in deletions:+ self.index_constructor.remove_constituent(symbol)+ changes['deletions'].append(symbol)++ # Add new constituents+ if additions:+ for constituent in additions:+ self.index_constructor.add_constituent(constituent)+ changes['additions'].append(constituent.symbol)++ changes['after_count'] = len(self.index_constructor.constituents)++ # Recalculate weights after reconstitution+ new_weights = self.index_constructor.calculate_weights()+ changes['new_weights'] = new_weights++ return changes+++class IndexAnalyzer(BaseMarketAnalysisModel):+ """Comprehensive index analysis and comparison"""++ def __init__(self):+ super().__init__("Index Analyzer", "Comprehensive index analysis")++ def validate_inputs(self, **kwargs) -> bool:+ """Validate inputs for index analysis"""+ index_data = kwargs.get('index_data')+ if index_data is None or index_data.empty:+ raise ValidationError("Index data is required for analysis")+ return True++ def analyze_market_data(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze index market data"""+ return self.comprehensive_index_analysis(market_data)++ def comprehensive_index_analysis(self, index_data: pd.DataFrame) -> Dict[str, Any]:+ """Perform comprehensive index analysis"""++ # Calculate returns+ price_returns = index_data['Close'].pct_change().dropna()++ # Performance metrics+ total_return = (index_data['Close'].iloc[-1] / index_data['Close'].iloc[0]) - 1+ annualized_return = ((1 + total_return) ** (252 / len(index_data))) - 1+ volatility = IndexCalculator.calculate_index_volatility(price_returns)+ sharpe_ratio = annualized_return / volatility if volatility > 0 else 0++ # Risk metrics+ max_drawdown = self.calculate_maximum_drawdown(index_data['Close'])+ var_95 = np.percentile(price_returns, 5)+ var_99 = np.percentile(price_returns, 1)++ # Performance by periods+ performance_periods = self.calculate_period_performance(index_data)++ return {+ 'performance_summary': {+ 'total_return': total_return,+ 'annualized_return': annualized_return,+ 'volatility': volatility,+ 'sharpe_ratio': sharpe_ratio,+ 'max_drawdown': max_drawdown,+ 'var_95': var_95,+ 'var_99': var_99+ },+ 'period_performance': performance_periods,+ 'statistical_measures': {+ 'skewness': price_returns.skew(),+ 'kurtosis': price_returns.kurtosis(),+ 'positive_days': (price_returns > 0).sum() / len(price_returns),+ 'average_positive_return': price_returns[price_returns > 0].mean(),+ 'average_negative_return': price_returns[price_returns < 0].mean()+ }+ }++ def calculate_maximum_drawdown(self, price_series: pd.Series) -> float:+ """Calculate maximum drawdown"""+ cumulative = (1 + price_series.pct_change()).cumprod()+ running_max = cumulative.expanding().max()+ drawdown = (cumulative - running_max) / running_max+ return drawdown.min()++ def calculate_period_performance(self, index_data: pd.DataFrame) -> Dict[str, float]:+ """Calculate performance over different periods"""++ current_price = index_data['Close'].iloc[-1]++ periods = {+ '1_day': 1,+ '1_week': 5,+ '1_month': 21,+ '3_months': 63,+ '6_months': 126,+ '1_year': 252,+ '3_years': 756,+ '5_years': 1260+ }++ performance = {}++ for period_name, days in periods.items():+ if len(index_data) > days:+ past_price = index_data['Close'].iloc[-days - 1]+ period_return = (current_price / past_price) - 1+ performance[period_name] = period_return++ return performance++ def compare_indexes(self, index_data_dict: Dict[str, pd.DataFrame]) -> Dict[str, Any]:+ """Compare multiple indexes"""++ comparison_results = {}++ for index_name, data in index_data_dict.items():+ analysis = self.comprehensive_index_analysis(data)+ comparison_results[index_name] = analysis['performance_summary']++ # Create comparison matrix+ metrics = ['total_return', 'annualized_return', 'volatility', 'sharpe_ratio', 'max_drawdown']+ comparison_matrix = pd.DataFrame(+ {metric: {name: results[metric] for name, results in comparison_results.items()}+ for metric in metrics}+ ).T++ # Rankings+ rankings = {}+ for metric in metrics:+ ascending = metric in ['volatility', 'max_drawdown'] # Lower is better for these+ rankings[metric] = comparison_matrix.loc[metric].rank(ascending=ascending)++ return {+ 'individual_analysis': comparison_results,+ 'comparison_matrix': comparison_matrix.to_dict(),+ 'rankings': rankings+ }++ def analyze_index_composition(self, constituents: List[IndexConstituent]) -> Dict[str, Any]:+ """Analyze index composition and concentration"""++ if not constituents:+ return {'error': 'No constituents provided'}++ # Sector analysis+ sector_weights = {}+ for constituent in constituents:+ sector = constituent.sector+ if sector in sector_weights:+ sector_weights[sector] += constituent.weight+ else:+ sector_weights[sector] = constituent.weight++ # Concentration metrics+ weights = [c.weight for c in constituents]++ # Herfindahl-Hirschman Index (concentration measure)+ hhi = sum(w ** 2 for w in weights)++ # Top holdings concentration+ sorted_weights = sorted(weights, reverse=True)+ top_5_concentration = sum(sorted_weights[:5]) if len(sorted_weights) >= 5 else sum(sorted_weights)+ top_10_concentration = sum(sorted_weights[:10]) if len(sorted_weights) >= 10 else sum(sorted_weights)++ # Effective number of stocks+ effective_stocks = 1 / hhi if hhi > 0 else len(constituents)++ return {+ 'composition_metrics': {+ 'total_constituents': len(constituents),+ 'herfindahl_index': hhi,+ 'effective_number_of_stocks': effective_stocks,+ 'top_5_concentration': top_5_concentration,+ 'top_10_concentration': top_10_concentration+ },+ 'sector_allocation': sector_weights,+ 'largest_holdings': [+ {+ 'symbol': c.symbol,+ 'name': c.name,+ 'weight': c.weight,+ 'sector': c.sector+ }+ for c in sorted(constituents, key=lambda x: x.weight, reverse=True)[:10]+ ]+ }+++class SpecializedIndexes:+ """Implementation of specialized index types"""++ @staticmethod+ def create_equity_index(constituents: List[IndexConstituent],+ weighting_method: IndexWeightingMethod = IndexWeightingMethod.MARKET_CAP_WEIGHTED,+ name: str = "Custom Equity Index") -> IndexConstructor:+ """Create equity index"""++ index = IndexConstructor(name, weighting_method)+ for constituent in constituents:+ index.add_constituent(constituent)++ return index++ @staticmethod+ def create_fixed_income_index(bond_data: List[Dict[str, Any]],+ name: str = "Custom Bond Index") -> Dict[str, Any]:+ """Create fixed income index (simplified)"""++ total_market_value = sum(bond['market_value'] for bond in bond_data)++ weighted_yield = sum(+ (bond['market_value'] / total_market_value) * bond['yield']+ for bond in bond_data+ )++ weighted_duration = sum(+ (bond['market_value'] / total_market_value) * bond['duration']+ for bond in bond_data+ )++ weighted_credit_quality = sum(+ (bond['market_value'] / total_market_value) * bond.get('credit_score', 0)+ for bond in bond_data+ )++ return {+ 'name': name,+ 'total_market_value': total_market_value,+ 'weighted_yield': weighted_yield,+ 'weighted_duration': weighted_duration,+ 'weighted_credit_quality': weighted_credit_quality,+ 'number_of_bonds': len(bond_data)+ }++ @staticmethod+ def create_commodity_index(commodity_data: List[Dict[str, Any]],+ name: str = "Custom Commodity Index") -> Dict[str, Any]:+ """Create commodity index"""++ total_weight = sum(commodity['weight'] for commodity in commodity_data)++ # Normalize weights+ for commodity in commodity_data:+ commodity['normalized_weight'] = commodity['weight'] / total_weight++ # Calculate index value (simplified)+ index_value = sum(+ commodity['normalized_weight'] * commodity['price_index']+ for commodity in commodity_data+ )++ return {+ 'name': name,+ 'index_value': index_value,+ 'constituents': commodity_data,+ 'sectors': list(set(c.get('sector', 'Unknown') for c in commodity_data))+ }+++# Convenience functions+def create_price_weighted_index(symbols: List[str], prices: List[float],+ names: List[str] = None) -> IndexConstructor:+ """Quick price-weighted index creation"""++ index = IndexConstructor("Price Weighted Index", IndexWeightingMethod.PRICE_WEIGHTED)++ for i, symbol in enumerate(symbols):+ name = names[i] if names and i < len(names) else symbol+ constituent = IndexConstituent(+ symbol=symbol,+ name=name,+ shares_outstanding=1000000, # Default+ float_shares=1000000,+ current_price=prices[i],+ market_cap=prices[i] * 1000000,+ weight=0, # Will be calculated+ sector="Unknown"+ )+ index.add_constituent(constituent)++ return index+++def create_market_cap_index(symbols: List[str], prices: List[float],+ shares: List[float], names: List[str] = None) -> IndexConstructor:+ """Quick market cap weighted index creation"""++ index = IndexConstructor("Market Cap Weighted Index", IndexWeightingMethod.MARKET_CAP_WEIGHTED)++ for i, symbol in enumerate(symbols):+ name = names[i] if names and i < len(names) else symbol+ constituent = IndexConstituent(+ symbol=symbol,+ name=name,+ shares_outstanding=shares[i],+ float_shares=shares[i] * 0.8, # Assume 80% float+ current_price=prices[i],+ market_cap=prices[i] * shares[i],+ weight=0, # Will be calculated+ sector="Unknown"+ )+ index.add_constituent(constituent)++ return index\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_efficiency.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_efficiency.pynew file mode 100644index 000000000..17506f504--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_efficiency.py@@ -0,0 +1,719 @@++Equity Investment Market Efficiency Module+======================================++Market efficiency and anomaly analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple+from dataclasses import dataclass+import scipy.stats as stats+from sklearn.linear_model import LinearRegression+import warnings++warnings.filterwarnings('ignore')++from .base_models import (+ BaseMarketAnalysisModel, MarketEfficiencyForm, ValidationError,+ FinceptAnalyticsError+)+++@dataclass+class EfficiencyTestResult:+ """Result structure for efficiency tests"""+ test_name: str+ efficiency_form: MarketEfficiencyForm+ test_statistic: float+ p_value: float+ is_efficient: bool+ confidence_level: float+ interpretation: str+++class MarketEfficiencyTester(BaseMarketAnalysisModel):+ """Market efficiency testing framework"""++ def __init__(self):+ super().__init__("Market Efficiency Tester", "Tests for various forms of market efficiency")+ self.significance_level = 0.05++ def validate_inputs(self, **kwargs) -> bool:+ """Validate inputs for efficiency tests"""+ price_data = kwargs.get('price_data')+ if price_data is None or price_data.empty:+ raise ValidationError("Price data is required for efficiency tests")++ if 'Close' not in price_data.columns:+ raise ValidationError("Price data must contain 'Close' column")++ return True++ def analyze_market_data(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Comprehensive market efficiency analysis"""++ results = {+ 'weak_form_tests': self.test_weak_form_efficiency(market_data),+ 'semi_strong_tests': self.test_semi_strong_efficiency(market_data),+ 'strong_form_tests': self.test_strong_form_efficiency(market_data),+ 'anomalies': self.detect_market_anomalies(market_data),+ 'overall_assessment': {}+ }++ # Overall efficiency assessment+ weak_efficient = results['weak_form_tests']['is_efficient']+ semi_strong_efficient = results['semi_strong_tests']['is_efficient']+ strong_efficient = results['strong_form_tests']['is_efficient']++ if strong_efficient:+ efficiency_level = "Strong-form efficient"+ elif semi_strong_efficient:+ efficiency_level = "Semi-strong-form efficient"+ elif weak_efficient:+ efficiency_level = "Weak-form efficient"+ else:+ efficiency_level = "Inefficient"++ results['overall_assessment'] = {+ 'efficiency_level': efficiency_level,+ 'weak_form_efficient': weak_efficient,+ 'semi_strong_form_efficient': semi_strong_efficient,+ 'strong_form_efficient': strong_efficient,+ 'anomalies_detected': len(results['anomalies']) > 0+ }++ return results+++class WeakFormEfficiencyTester:+ """Tests for weak-form market efficiency"""++ def __init__(self, significance_level: float = 0.05):+ self.significance_level = significance_level++ def runs_test(self, returns: pd.Series) -> EfficiencyTestResult:+ """Runs test for randomness in return series"""++ # Convert returns to binary sequence (above/below median)+ median_return = returns.median()+ binary_sequence = (returns > median_return).astype(int)++ # Count runs+ runs = 1+ for i in range(1, len(binary_sequence)):+ if binary_sequence.iloc[i] != binary_sequence.iloc[i - 1]:+ runs += 1++ # Calculate expected runs and variance+ n1 = sum(binary_sequence) # Number of 1s+ n2 = len(binary_sequence) - n1 # Number of 0s+ n = len(binary_sequence)++ expected_runs = (2 * n1 * n2) / n + 1+ variance_runs = (2 * n1 * n2 * (2 * n1 * n2 - n)) / (n ** 2 * (n - 1))++ # Test statistic+ if variance_runs > 0:+ z_stat = (runs - expected_runs) / np.sqrt(variance_runs)+ p_value = 2 * (1 - stats.norm.cdf(abs(z_stat)))+ else:+ z_stat = 0+ p_value = 1++ is_efficient = p_value > self.significance_level++ return EfficiencyTestResult(+ test_name="Runs Test",+ efficiency_form=MarketEfficiencyForm.WEAK,+ test_statistic=z_stat,+ p_value=p_value,+ is_efficient=is_efficient,+ confidence_level=1 - self.significance_level,+ interpretation=f"Returns appear {'random' if is_efficient else 'non-random'} (p-value: {p_value:.4f})"+ )++ def autocorrelation_test(self, returns: pd.Series, lags: List[int] = None) -> Dict[str, EfficiencyTestResult]:+ """Test for autocorrelation in returns at various lags"""++ if lags is None:+ lags = [1, 5, 10, 20]++ results = {}++ for lag in lags:+ if len(returns) <= lag:+ continue++ # Calculate autocorrelation+ autocorr = returns.autocorr(lag=lag)++ # Test statistic (Box-Pierce test approximation)+ n = len(returns)+ test_stat = n * (autocorr ** 2)+ p_value = 1 - stats.chi2.cdf(test_stat, df=1)++ is_efficient = p_value > self.significance_level++ results[f'lag_{lag}'] = EfficiencyTestResult(+ test_name=f"Autocorrelation Test (Lag {lag})",+ efficiency_form=MarketEfficiencyForm.WEAK,+ test_statistic=autocorr,+ p_value=p_value,+ is_efficient=is_efficient,+ confidence_level=1 - self.significance_level,+ interpretation=f"Lag {lag} autocorrelation: {autocorr:.4f} ({'not significant' if is_efficient else 'significant'})"+ )++ return results++ def variance_ratio_test(self, returns: pd.Series, periods: List[int] = None) -> Dict[str, EfficiencyTestResult]:+ """Variance ratio test for random walk"""++ if periods is None:+ periods = [2, 4, 8, 16]++ results = {}++ for k in periods:+ if len(returns) < k * 10: # Need sufficient observations+ continue++ # Calculate variance ratios+ var_1 = returns.var()++ # k-period returns+ k_returns = returns.rolling(k).sum().dropna()+ var_k = k_returns.var()++ # Variance ratio+ variance_ratio = var_k / (k * var_1)++ # Test statistic under random walk hypothesis+ n = len(returns)+ test_stat = np.sqrt(n) * (variance_ratio - 1) / np.sqrt(2 * (k - 1))+ p_value = 2 * (1 - stats.norm.cdf(abs(test_stat)))++ is_efficient = p_value > self.significance_level++ results[f'period_{k}'] = EfficiencyTestResult(+ test_name=f"Variance Ratio Test (Period {k})",+ efficiency_form=MarketEfficiencyForm.WEAK,+ test_statistic=variance_ratio,+ p_value=p_value,+ is_efficient=is_efficient,+ confidence_level=1 - self.significance_level,+ interpretation=f"VR({k}) = {variance_ratio:.4f} ({'consistent with' if is_efficient else 'inconsistent with'} random walk)"+ )++ return results+++class SemiStrongFormTester:+ """Tests for semi-strong form market efficiency"""++ def __init__(self, significance_level: float = 0.05):+ self.significance_level = significance_level++ def event_study_analysis(self, price_data: pd.DataFrame, event_dates: List[str],+ estimation_window: int = 250, event_window: int = 21) -> Dict[str, Any]:+ """Event study analysis to test market reaction to new information"""++ if 'Close' not in price_data.columns:+ raise ValidationError("Price data must contain 'Close' column")++ # Calculate returns+ returns = price_data['Close'].pct_change().dropna()++ results = []++ for event_date in event_dates:+ try:+ event_idx = returns.index.get_loc(pd.to_datetime(event_date))+ except KeyError:+ continue++ # Define windows+ est_start = max(0, event_idx - estimation_window - event_window // 2)+ est_end = event_idx - event_window // 2+ event_start = event_idx - event_window // 2+ event_end = event_idx + event_window // 2++ if est_start >= est_end or event_start >= len(returns):+ continue++ # Estimation period returns+ estimation_returns = returns.iloc[est_start:est_end]++ # Event period returns+ event_returns = returns.iloc[event_start:event_end + 1]++ # Calculate normal performance (market model)+ # Simplified: use mean return during estimation period+ expected_return = estimation_returns.mean()++ # Calculate abnormal returns+ abnormal_returns = event_returns - expected_return++ # Cumulative abnormal returns+ cumulative_ar = abnormal_returns.cumsum()++ # Test statistics+ ar_std = estimation_returns.std()+ t_stat = abnormal_returns.mean() / (ar_std / np.sqrt(len(abnormal_returns)))+ p_value = 2 * (1 - stats.t.cdf(abs(t_stat), df=len(estimation_returns) - 1))++ results.append({+ 'event_date': event_date,+ 'abnormal_returns': abnormal_returns.tolist(),+ 'cumulative_abnormal_return': cumulative_ar.iloc[-1],+ 'average_abnormal_return': abnormal_returns.mean(),+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'is_significant': p_value < self.significance_level+ })++ # Overall assessment+ significant_events = sum(1 for r in results if r['is_significant'])+ efficiency_assessment = significant_events / len(results) if results else 0++ return {+ 'individual_events': results,+ 'total_events': len(results),+ 'significant_events': significant_events,+ 'efficiency_ratio': 1 - efficiency_assessment, # Higher ratio = more efficient+ 'is_efficient': efficiency_assessment < 0.1, # Less than 10% significant events+ 'interpretation': f"Market shows {'strong' if efficiency_assessment < 0.05 else 'moderate' if efficiency_assessment < 0.15 else 'weak'} semi-strong efficiency"+ }++ def post_announcement_drift_test(self, price_data: pd.DataFrame,+ earnings_announcement_dates: List[str]) -> Dict[str, Any]:+ """Test for post-earnings announcement drift"""++ returns = price_data['Close'].pct_change().dropna()++ drift_periods = [5, 10, 20, 60] # Days after announcement+ results = {}++ for period in drift_periods:+ cumulative_returns = []++ for announcement_date in earnings_announcement_dates:+ try:+ announcement_idx = returns.index.get_loc(pd.to_datetime(announcement_date))++ if announcement_idx + period < len(returns):+ post_returns = returns.iloc[announcement_idx + 1:announcement_idx + period + 1]+ cumulative_return = (1 + post_returns).prod() - 1+ cumulative_returns.append(cumulative_return)++ except (KeyError, IndexError):+ continue++ if cumulative_returns:+ avg_drift = np.mean(cumulative_returns)+ drift_std = np.std(cumulative_returns)+ t_stat = avg_drift / (drift_std / np.sqrt(len(cumulative_returns)))+ p_value = 2 * (1 - stats.t.cdf(abs(t_stat), df=len(cumulative_returns) - 1))++ results[f'{period}_day'] = {+ 'average_drift': avg_drift,+ 'drift_std': drift_std,+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'is_significant': p_value < self.significance_level,+ 'sample_size': len(cumulative_returns)+ }++ return results+++class StrongFormTester:+ """Tests for strong-form market efficiency"""++ def __init__(self, significance_level: float = 0.05):+ self.significance_level = significance_level++ def insider_trading_analysis(self, price_data: pd.DataFrame,+ insider_transaction_dates: List[Dict[str, Any]]) -> Dict[str, Any]:+ """Analyze abnormal returns around insider trading dates"""++ returns = price_data['Close'].pct_change().dropna()++ buy_returns = []+ sell_returns = []++ for transaction in insider_transaction_dates:+ transaction_date = transaction.get('date')+ transaction_type = transaction.get('type') # 'buy' or 'sell'++ try:+ transaction_idx = returns.index.get_loc(pd.to_datetime(transaction_date))++ # Look at returns in the following 30 days+ if transaction_idx + 30 < len(returns):+ future_returns = returns.iloc[transaction_idx + 1:transaction_idx + 31]+ cumulative_return = (1 + future_returns).prod() - 1++ if transaction_type.lower() == 'buy':+ buy_returns.append(cumulative_return)+ elif transaction_type.lower() == 'sell':+ sell_returns.append(cumulative_return)++ except (KeyError, IndexError):+ continue++ results = {}++ # Analyze buy transactions+ if buy_returns:+ avg_buy_return = np.mean(buy_returns)+ buy_std = np.std(buy_returns)+ buy_t_stat = avg_buy_return / (buy_std / np.sqrt(len(buy_returns)))+ buy_p_value = stats.t.sf(buy_t_stat, df=len(buy_returns) - 1) # One-tailed test++ results['insider_buys'] = {+ 'average_return': avg_buy_return,+ 'sample_size': len(buy_returns),+ 't_statistic': buy_t_stat,+ 'p_value': buy_p_value,+ 'outperforms_market': buy_p_value < self.significance_level and avg_buy_return > 0+ }++ # Analyze sell transactions+ if sell_returns:+ avg_sell_return = np.mean(sell_returns)+ sell_std = np.std(sell_returns)+ sell_t_stat = avg_sell_return / (sell_std / np.sqrt(len(sell_returns)))+ sell_p_value = stats.t.cdf(sell_t_stat, df=len(sell_returns) - 1) # One-tailed test (negative)++ results['insider_sells'] = {+ 'average_return': avg_sell_return,+ 'sample_size': len(sell_returns),+ 't_statistic': sell_t_stat,+ 'p_value': sell_p_value,+ 'underperforms_market': sell_p_value < self.significance_level and avg_sell_return < 0+ }++ # Overall strong-form efficiency assessment+ insider_advantage = False++ if results.get('insider_buys', {}).get('outperforms_market', False):+ insider_advantage = True+ if results.get('insider_sells', {}).get('underperforms_market', False):+ insider_advantage = True++ results['strong_form_efficient'] = not insider_advantage++ return results++ def mutual_fund_performance_analysis(self, fund_returns: pd.DataFrame,+ market_returns: pd.Series) -> Dict[str, Any]:+ """Analyze mutual fund performance for strong-form efficiency"""++ results = {}++ for fund_name in fund_returns.columns:+ fund_return_series = fund_returns[fund_name].dropna()++ # Align dates+ common_dates = fund_return_series.index.intersection(market_returns.index)+ fund_aligned = fund_return_series.loc[common_dates]+ market_aligned = market_returns.loc[common_dates]++ if len(fund_aligned) < 50: # Need sufficient observations+ continue++ # Calculate alpha (Jensen's alpha)+ # Simplified CAPM: Fund Return = Alpha + Beta * Market Return + Error+ X = market_aligned.values.reshape(-1, 1)+ y = fund_aligned.values++ model = LinearRegression()+ model.fit(X, y)++ alpha = model.intercept_+ beta = model.coef_[0]++ # Calculate t-statistic for alpha+ y_pred = model.predict(X)+ residuals = y - y_pred+ mse = np.mean(residuals ** 2)++ # Standard error of alpha+ x_mean = np.mean(market_aligned)+ alpha_se = np.sqrt(mse * (1 / len(fund_aligned) + x_mean ** 2 / np.sum((market_aligned - x_mean) ** 2)))++ alpha_t_stat = alpha / alpha_se if alpha_se > 0 else 0+ alpha_p_value = 2 * (1 - stats.t.cdf(abs(alpha_t_stat), df=len(fund_aligned) - 2))++ results[fund_name] = {+ 'alpha': alpha,+ 'beta': beta,+ 'alpha_t_statistic': alpha_t_stat,+ 'alpha_p_value': alpha_p_value,+ 'significant_alpha': alpha_p_value < self.significance_level,+ 'excess_return': alpha * 252, # Annualized alpha+ 'sample_size': len(fund_aligned)+ }++ # Overall assessment+ funds_with_significant_alpha = sum(1 for f in results.values() if f['significant_alpha'])+ total_funds = len(results)++ strong_form_efficient = (funds_with_significant_alpha / total_funds) < 0.05 if total_funds > 0 else True++ return {+ 'individual_funds': results,+ 'total_funds_analyzed': total_funds,+ 'funds_with_significant_alpha': funds_with_significant_alpha,+ 'percentage_significant': (funds_with_significant_alpha / total_funds * 100) if total_funds > 0 else 0,+ 'strong_form_efficient': strong_form_efficient+ }+++class MarketAnomalyDetector:+ """Detect various market anomalies"""++ def detect_calendar_anomalies(self, price_data: pd.DataFrame) -> Dict[str, Any]:+ """Detect calendar-based anomalies"""++ returns = price_data['Close'].pct_change().dropna()+ returns.index = pd.to_datetime(returns.index)++ anomalies = {}++ # Day-of-the-week effect+ returns_by_weekday = returns.groupby(returns.index.dayofweek)+ weekday_means = returns_by_weekday.mean()+ weekday_stats = {}++ for day in range(5): # Monday=0 to Friday=4+ day_returns = returns_by_weekday.get_group(day) if day in returns_by_weekday.groups else pd.Series([])+ if len(day_returns) > 10:+ t_stat, p_value = stats.ttest_1samp(day_returns, 0)+ weekday_stats[day] = {+ 'mean_return': day_returns.mean(),+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'sample_size': len(day_returns)+ }++ anomalies['day_of_week'] = weekday_stats++ # Month-of-the-year effect+ returns_by_month = returns.groupby(returns.index.month)+ monthly_stats = {}++ for month in range(1, 13):+ month_returns = returns_by_month.get_group(month) if month in returns_by_month.groups else pd.Series([])+ if len(month_returns) > 5:+ t_stat, p_value = stats.ttest_1samp(month_returns, 0)+ monthly_stats[month] = {+ 'mean_return': month_returns.mean(),+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'sample_size': len(month_returns)+ }++ anomalies['month_of_year'] = monthly_stats++ # January effect+ january_returns = returns[returns.index.month == 1]+ other_returns = returns[returns.index.month != 1]++ if len(january_returns) > 5 and len(other_returns) > 5:+ january_mean = january_returns.mean()+ other_mean = other_returns.mean()+ t_stat, p_value = stats.ttest_ind(january_returns, other_returns)++ anomalies['january_effect'] = {+ 'january_mean': january_mean,+ 'other_months_mean': other_mean,+ 'difference': january_mean - other_mean,+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'january_outperforms': january_mean > other_mean and p_value < 0.05+ }++ return anomalies++ def detect_size_anomaly(self, price_data: pd.DataFrame, market_cap_data: pd.Series) -> Dict[str, Any]:+ """Detect size anomaly (small-cap outperformance)"""++ returns = price_data['Close'].pct_change().dropna()++ # Align market cap data with returns+ aligned_cap = market_cap_data.reindex(returns.index).fillna(method='ffill')++ # Create size deciles+ deciles = pd.qcut(aligned_cap, 10, labels=False)++ decile_returns = {}+ for decile in range(10):+ decile_mask = deciles == decile+ decile_return_series = returns[decile_mask]++ if len(decile_return_series) > 20:+ decile_returns[decile + 1] = {+ 'mean_return': decile_return_series.mean(),+ 'volatility': decile_return_series.std(),+ 'sharpe_ratio': decile_return_series.mean() / decile_return_series.std() if decile_return_series.std() > 0 else 0,+ 'sample_size': len(decile_return_series)+ }++ # Test if smallest decile outperforms largest+ if 1 in decile_returns and 10 in decile_returns:+ small_returns = returns[deciles == 0]+ large_returns = returns[deciles == 9]++ t_stat, p_value = stats.ttest_ind(small_returns, large_returns)++ size_anomaly = {+ 'decile_performance': decile_returns,+ 'small_vs_large_test': {+ 'small_cap_mean': small_returns.mean(),+ 'large_cap_mean': large_returns.mean(),+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'small_outperforms': small_returns.mean() > large_returns.mean() and p_value < 0.05+ }+ }+ else:+ size_anomaly = {'decile_performance': decile_returns}++ return size_anomaly++ def detect_momentum_anomaly(self, price_data: pd.DataFrame, lookback_period: int = 252) -> Dict[str, Any]:+ """Detect momentum anomaly"""++ returns = price_data['Close'].pct_change().dropna()++ # Calculate momentum (past year return excluding last month)+ momentum_returns = returns.rolling(lookback_period).apply(lambda x: (1 + x[:-21]).prod() - 1, raw=False)++ # Next month returns+ future_returns = returns.shift(-21).rolling(21).apply(lambda x: (1 + x).prod() - 1, raw=False)++ # Combine data+ momentum_data = pd.DataFrame({+ 'momentum': momentum_returns,+ 'future_return': future_returns+ }).dropna()++ if len(momentum_data) < 50:+ return {'error': 'Insufficient data for momentum analysis'}++ # Create momentum deciles+ momentum_deciles = pd.qcut(momentum_data['momentum'], 10, labels=False)++ decile_performance = {}+ for decile in range(10):+ decile_mask = momentum_deciles == decile+ decile_future_returns = momentum_data['future_return'][decile_mask]++ if len(decile_future_returns) > 5:+ decile_performance[decile + 1] = {+ 'mean_future_return': decile_future_returns.mean(),+ 'std_future_return': decile_future_returns.std(),+ 'sample_size': len(decile_future_returns)+ }++ # Test winner vs loser portfolio+ if 1 in decile_performance and 10 in decile_performance:+ loser_returns = momentum_data['future_return'][momentum_deciles == 0]+ winner_returns = momentum_data['future_return'][momentum_deciles == 9]++ t_stat, p_value = stats.ttest_ind(winner_returns, loser_returns)++ momentum_test = {+ 'winner_mean': winner_returns.mean(),+ 'loser_mean': loser_returns.mean(),+ 'winner_minus_loser': winner_returns.mean() - loser_returns.mean(),+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'momentum_exists': winner_returns.mean() > loser_returns.mean() and p_value < 0.05+ }+ else:+ momentum_test = {}++ return {+ 'decile_performance': decile_performance,+ 'momentum_test': momentum_test+ }+++def comprehensive_efficiency_analysis(price_data: pd.DataFrame,+ event_dates: List[str] = None,+ insider_transactions: List[Dict[str, Any]] = None) -> Dict[str, Any]:+ """Perform comprehensive market efficiency analysis"""++ # Initialize testers+ weak_tester = WeakFormEfficiencyTester()+ semi_strong_tester = SemiStrongFormTester()+ strong_tester = StrongFormTester()+ anomaly_detector = MarketAnomalyDetector()++ returns = price_data['Close'].pct_change().dropna()++ results = {+ 'data_summary': {+ 'start_date': returns.index[0].strftime('%Y-%m-%d'),+ 'end_date': returns.index[-1].strftime('%Y-%m-%d'),+ 'total_observations': len(returns),+ 'mean_return': returns.mean(),+ 'volatility': returns.std(),+ 'skewness': returns.skew(),+ 'kurtosis': returns.kurtosis()+ }+ }++ # Weak-form tests+ results['weak_form'] = {+ 'runs_test': weak_tester.runs_test(returns),+ 'autocorrelation_tests': weak_tester.autocorrelation_test(returns),+ 'variance_ratio_tests': weak_tester.variance_ratio_test(returns)+ }++ # Semi-strong form tests+ if event_dates:+ results['semi_strong'] = {+ 'event_study': semi_strong_tester.event_study_analysis(price_data, event_dates)+ }++ # Strong-form tests+ if insider_transactions:+ results['strong_form'] = {+ 'insider_trading': strong_tester.insider_trading_analysis(price_data, insider_transactions)+ }++ # Anomaly detection+ results['anomalies'] = {+ 'calendar_anomalies': anomaly_detector.detect_calendar_anomalies(price_data),+ 'momentum_anomaly': anomaly_detector.detect_momentum_anomaly(price_data)+ }++ return results\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_structure.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_structure.pynew file mode 100644index 000000000..cee7e38fb--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/market_analysis/market_structure.py@@ -0,0 +1,933 @@++Equity Investment Market Structure Module+======================================++Market structure and microstructure analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple, Union+from dataclasses import dataclass+from enum import Enum+import warnings++from fincept_terminal.Analytics.equityInvestment.base.base_models import (+ BaseMarketAnalysisModel, SecurityType, ValidationError,+ FinceptAnalyticsError+)+++class MarketType(Enum):+ """Types of financial markets"""+ QUOTE_DRIVEN = "quote_driven"+ ORDER_DRIVEN = "order_driven"+ BROKERED = "brokered"+ HYBRID = "hybrid"+++class OrderType(Enum):+ """Types of trading orders"""+ MARKET_ORDER = "market_order"+ LIMIT_ORDER = "limit_order"+ STOP_ORDER = "stop_order"+ STOP_LIMIT_ORDER = "stop_limit_order"+++class OrderValidity(Enum):+ """Order validity instructions"""+ DAY_ORDER = "day_order"+ GOOD_TILL_CANCELED = "good_till_canceled"+ IMMEDIATE_OR_CANCEL = "immediate_or_cancel"+ FILL_OR_KILL = "fill_or_kill"+++class PositionType(Enum):+ """Investment position types"""+ LONG = "long"+ SHORT = "short"+++@dataclass+class SecurityCharacteristics:+ """Security characteristics structure"""+ security_type: SecurityType+ voting_rights: bool+ dividend_rights: bool+ residual_claim: bool+ maturity: Optional[str]+ coupon_rate: Optional[float]+ face_value: Optional[float]+ callable: bool+ convertible: bool+++@dataclass+class MarginAccountData:+ """Margin account information"""+ initial_margin_requirement: float+ maintenance_margin_requirement: float+ account_equity: float+ total_value: float+ borrowed_amount: float+ leverage_ratio: float+++@dataclass+class TradingOrder:+ """Trading order structure"""+ order_type: OrderType+ order_validity: OrderValidity+ security_symbol: str+ quantity: int+ price: Optional[float]+ stop_price: Optional[float]+ position_type: PositionType+++class SecurityClassifier:+ """Classify and analyze different types of securities"""++ def __init__(self):+ # Security type characteristics+ self.security_characteristics = {+ SecurityType.COMMON_STOCK: {+ 'voting_rights': True,+ 'dividend_rights': True,+ 'residual_claim': True,+ 'maturity': None,+ 'priority_in_liquidation': 'Last',+ 'income_type': 'Variable',+ 'risk_level': 'High'+ },+ SecurityType.PREFERRED_STOCK: {+ 'voting_rights': False,+ 'dividend_rights': True,+ 'residual_claim': False,+ 'maturity': None,+ 'priority_in_liquidation': 'Before Common',+ 'income_type': 'Fixed',+ 'risk_level': 'Medium'+ },+ SecurityType.CORPORATE_BOND: {+ 'voting_rights': False,+ 'dividend_rights': False,+ 'residual_claim': False,+ 'maturity': 'Fixed',+ 'priority_in_liquidation': 'Before Equity',+ 'income_type': 'Fixed',+ 'risk_level': 'Low-Medium'+ },+ SecurityType.GOVERNMENT_BOND: {+ 'voting_rights': False,+ 'dividend_rights': False,+ 'residual_claim': False,+ 'maturity': 'Fixed',+ 'priority_in_liquidation': 'Highest',+ 'income_type': 'Fixed',+ 'risk_level': 'Low'+ }+ }++ def classify_equity_security(self, characteristics: Dict[str, Any]) -> Dict[str, Any]:+ """Classify equity security and its features"""++ voting_rights = characteristics.get('voting_rights', True)+ dividend_preference = characteristics.get('dividend_preference', False)+ cumulative_dividends = characteristics.get('cumulative_dividends', False)+ callable = characteristics.get('callable', False)+ convertible = characteristics.get('convertible', False)++ # Determine security type+ if dividend_preference:+ security_type = SecurityType.PREFERRED_STOCK+ risk_level = "Medium"+ else:+ security_type = SecurityType.COMMON_STOCK+ risk_level = "High"++ # Additional features+ features = []+ if cumulative_dividends:+ features.append("Cumulative Dividends")+ if callable:+ features.append("Callable")+ if convertible:+ features.append("Convertible")+ if not voting_rights:+ features.append("Non-Voting")++ return {+ 'security_type': security_type,+ 'risk_level': risk_level,+ 'voting_rights': voting_rights,+ 'dividend_preference': dividend_preference,+ 'special_features': features,+ 'investment_characteristics': self.get_investment_characteristics(security_type)+ }++ def classify_debt_security(self, characteristics: Dict[str, Any]) -> Dict[str, Any]:+ """Classify debt security and its features"""++ issuer_type = characteristics.get('issuer_type', 'Corporate')+ maturity_years = characteristics.get('maturity_years', 10)+ coupon_rate = characteristics.get('coupon_rate', 0.05)+ callable = characteristics.get('callable', False)+ convertible = characteristics.get('convertible', False)+ secured = characteristics.get('secured', False)++ # Determine security type and risk level+ if issuer_type.lower() in ['government', 'treasury', 'federal']:+ security_type = SecurityType.GOVERNMENT_BOND+ risk_level = "Low"+ else:+ security_type = SecurityType.CORPORATE_BOND+ risk_level = "Low-Medium"++ # Maturity classification+ if maturity_years <= 1:+ maturity_class = "Short-term"+ elif maturity_years <= 10:+ maturity_class = "Medium-term"+ else:+ maturity_class = "Long-term"++ # Special features+ features = []+ if callable:+ features.append("Callable")+ if convertible:+ features.append("Convertible")+ if secured:+ features.append("Secured")++ return {+ 'security_type': security_type,+ 'issuer_type': issuer_type,+ 'maturity_classification': maturity_class,+ 'risk_level': risk_level,+ 'coupon_rate': coupon_rate,+ 'special_features': features,+ 'investment_characteristics': self.get_investment_characteristics(security_type)+ }++ def get_investment_characteristics(self, security_type: SecurityType) -> Dict[str, str]:+ """Get investment characteristics for security type"""+ return self.security_characteristics.get(security_type, {})++ def compare_security_types(self, security_types: List[SecurityType]) -> pd.DataFrame:+ """Compare characteristics of different security types"""++ comparison_data = []++ for sec_type in security_types:+ characteristics = self.security_characteristics.get(sec_type, {})+ characteristics['security_type'] = sec_type.value+ comparison_data.append(characteristics)++ return pd.DataFrame(comparison_data)+++class MarginTradingCalculator:+ """Calculate margin trading metrics and requirements"""++ def __init__(self):+ # Standard margin requirements (can be customized)+ self.initial_margin_requirement = 0.50 # 50%+ self.maintenance_margin_requirement = 0.25 # 25%++ def calculate_margin_requirements(self, position_value: float,+ initial_margin: float = None,+ maintenance_margin: float = None) -> Dict[str, float]:+ """Calculate margin requirements for a position"""++ initial_req = initial_margin or self.initial_margin_requirement+ maintenance_req = maintenance_margin or self.maintenance_margin_requirement++ initial_margin_amount = position_value * initial_req+ maintenance_margin_amount = position_value * maintenance_req+ max_loan_amount = position_value - initial_margin_amount++ return {+ 'position_value': position_value,+ 'initial_margin_requirement': initial_req,+ 'initial_margin_amount': initial_margin_amount,+ 'maintenance_margin_requirement': maintenance_req,+ 'maintenance_margin_amount': maintenance_margin_amount,+ 'maximum_loan_amount': max_loan_amount,+ 'leverage_ratio': position_value / initial_margin_amount if initial_margin_amount > 0 else 0+ }++ def calculate_margin_call_price(self, initial_price: float, initial_margin: float,+ loan_amount: float, shares: int,+ maintenance_margin: float = None) -> float:+ """Calculate price at which margin call occurs"""++ maintenance_req = maintenance_margin or self.maintenance_margin_requirement++ # Margin call price = (Loan Amount) / (Shares × (1 - Maintenance Margin))+ margin_call_price = loan_amount / (shares * (1 - maintenance_req))++ return margin_call_price++ def calculate_margin_return(self, initial_price: float, final_price: float,+ initial_margin_percentage: float,+ interest_rate: float = 0, time_period: float = 1) -> Dict[str, float]:+ """Calculate return on margin transaction"""++ # Price change+ price_change_percentage = (final_price - initial_price) / initial_price++ # Leverage effect+ leverage_ratio = 1 / initial_margin_percentage++ # Interest cost on borrowed funds+ borrowed_percentage = 1 - initial_margin_percentage+ interest_cost = borrowed_percentage * interest_rate * time_period++ # Return on margin transaction+ margin_return = (price_change_percentage * leverage_ratio) - interest_cost++ # Compare to unleveraged return+ unleveraged_return = price_change_percentage++ return {+ 'unleveraged_return': unleveraged_return,+ 'margin_return': margin_return,+ 'leverage_ratio': leverage_ratio,+ 'interest_cost': interest_cost,+ 'leverage_benefit': margin_return - unleveraged_return+ }++ def analyze_margin_account(self, account_data: MarginAccountData) -> Dict[str, Any]:+ """Analyze margin account status"""++ # Current margin percentage+ current_margin = account_data.account_equity / account_data.total_value++ # Excess margin above maintenance requirement+ excess_margin = current_margin - account_data.maintenance_margin_requirement++ # Buying power+ buying_power = account_data.account_equity / account_data.initial_margin_requirement++ # Margin call status+ margin_call_needed = current_margin < account_data.maintenance_margin_requirement++ # Amount needed to meet maintenance requirement+ if margin_call_needed:+ required_equity = account_data.total_value * account_data.maintenance_margin_requirement+ margin_call_amount = required_equity - account_data.account_equity+ else:+ margin_call_amount = 0++ return {+ 'current_margin_percentage': current_margin,+ 'excess_margin': excess_margin,+ 'buying_power': buying_power,+ 'margin_call_needed': margin_call_needed,+ 'margin_call_amount': margin_call_amount,+ 'account_status': 'Margin Call' if margin_call_needed else 'Good Standing'+ }+++class OrderAnalyzer:+ """Analyze trading orders and execution instructions"""++ def analyze_market_order(self, order: TradingOrder, current_bid: float,+ current_ask: float) -> Dict[str, Any]:+ """Analyze market order characteristics"""++ if order.position_type == PositionType.LONG:+ expected_execution_price = current_ask+ price_impact = "Buy at ask price"+ else: # SHORT+ expected_execution_price = current_bid+ price_impact = "Sell at bid price"++ bid_ask_spread = current_ask - current_bid+ spread_percentage = bid_ask_spread / ((current_bid + current_ask) / 2) * 100++ return {+ 'order_type': order.order_type.value,+ 'execution_certainty': 'High',+ 'price_certainty': 'Low',+ 'expected_execution_price': expected_execution_price,+ 'bid_ask_spread': bid_ask_spread,+ 'spread_percentage': spread_percentage,+ 'price_impact': price_impact,+ 'advantages': ['Immediate execution', 'High fill probability'],+ 'disadvantages': ['Price uncertainty', 'Market impact cost']+ }++ def analyze_limit_order(self, order: TradingOrder, current_price: float) -> Dict[str, Any]:+ """Analyze limit order characteristics"""++ if not order.price:+ raise ValidationError("Limit order requires price specification")++ if order.position_type == PositionType.LONG:+ # Buy limit order+ executable = order.price >= current_price+ price_improvement = current_price - order.price if executable else 0+ else:+ # Sell limit order+ executable = order.price <= current_price+ price_improvement = order.price - current_price if executable else 0++ return {+ 'order_type': order.order_type.value,+ 'limit_price': order.price,+ 'current_market_price': current_price,+ 'immediately_executable': executable,+ 'price_improvement': price_improvement,+ 'execution_certainty': 'Medium',+ 'price_certainty': 'High',+ 'advantages': ['Price protection', 'Potential price improvement'],+ 'disadvantages': ['Execution uncertainty', 'Opportunity cost if not filled']+ }++ def analyze_stop_order(self, order: TradingOrder, current_price: float) -> Dict[str, Any]:+ """Analyze stop order characteristics"""++ if not order.stop_price:+ raise ValidationError("Stop order requires stop price specification")++ if order.position_type == PositionType.LONG:+ # Buy stop (stop above current price)+ activated = current_price >= order.stop_price+ order_purpose = "Momentum/Breakout buying"+ else:+ # Sell stop (stop below current price)+ activated = current_price <= order.stop_price+ order_purpose = "Loss limitation/Risk management"++ return {+ 'order_type': order.order_type.value,+ 'stop_price': order.stop_price,+ 'current_price': current_price,+ 'activated': activated,+ 'order_purpose': order_purpose,+ 'execution_certainty': 'Medium' if activated else 'Low',+ 'price_certainty': 'Low',+ 'advantages': ['Risk management', 'No monitoring required'],+ 'disadvantages': ['Price uncertainty when executed', 'Possible gap risk']+ }++ def compare_order_types(self, current_bid: float, current_ask: float) -> pd.DataFrame:+ """Compare characteristics of different order types"""++ order_comparison = [+ {+ 'order_type': 'Market Order',+ 'execution_certainty': 'High',+ 'price_certainty': 'Low',+ 'typical_use': 'Immediate execution needed',+ 'price_paid_received': f'Ask ({current_ask}) / Bid ({current_bid})'+ },+ {+ 'order_type': 'Limit Order',+ 'execution_certainty': 'Medium',+ 'price_certainty': 'High',+ 'typical_use': 'Price protection desired',+ 'price_paid_received': 'Limit price or better'+ },+ {+ 'order_type': 'Stop Order',+ 'execution_certainty': 'Medium',+ 'price_certainty': 'Low',+ 'typical_use': 'Risk management/Momentum',+ 'price_paid_received': 'Market price when triggered'+ },+ {+ 'order_type': 'Stop-Limit Order',+ 'execution_certainty': 'Low',+ 'price_certainty': 'High',+ 'typical_use': 'Risk management with price protection',+ 'price_paid_received': 'Limit price or better (if filled)'+ }+ ]++ return pd.DataFrame(order_comparison)+++class MarketStructureAnalyzer(BaseMarketAnalysisModel):+ """Analyze market structure and trading mechanisms"""++ def __init__(self):+ super().__init__("Market Structure Analyzer", "Market organization and structure analysis")++ def validate_inputs(self, **kwargs) -> bool:+ """Validate inputs for market structure analysis"""+ return True++ def analyze_market_data(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze market structure characteristics"""++ return {+ 'market_microstructure': self.analyze_market_microstructure(market_data),+ 'liquidity_analysis': self.analyze_market_liquidity(market_data),+ 'trading_costs': self.estimate_trading_costs(market_data),+ 'market_efficiency_indicators': self.calculate_efficiency_indicators(market_data)+ }++ def analyze_market_microstructure(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze market microstructure characteristics"""++ if 'Bid' not in market_data.columns or 'Ask' not in market_data.columns:+ return {'error': 'Bid and Ask data required for microstructure analysis'}++ # Bid-ask spread analysis+ spreads = market_data['Ask'] - market_data['Bid']+ relative_spreads = spreads / ((market_data['Bid'] + market_data['Ask']) / 2)++ # Volume analysis+ if 'Volume' in market_data.columns:+ volume_stats = {+ 'average_volume': market_data['Volume'].mean(),+ 'volume_volatility': market_data['Volume'].std(),+ 'high_volume_days': (market_data['Volume'] > market_data['Volume'].quantile(0.9)).sum()+ }+ else:+ volume_stats = {'error': 'Volume data not available'}++ return {+ 'bid_ask_spreads': {+ 'average_spread': spreads.mean(),+ 'average_relative_spread': relative_spreads.mean(),+ 'spread_volatility': spreads.std(),+ 'min_spread': spreads.min(),+ 'max_spread': spreads.max()+ },+ 'volume_statistics': volume_stats,+ 'market_depth_indicators': self.analyze_market_depth(market_data)+ }++ def analyze_market_depth(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze market depth characteristics"""++ # Simplified market depth analysis using bid-ask data+ if 'Bid' in market_data.columns and 'Ask' in market_data.columns:+ spreads = market_data['Ask'] - market_data['Bid']++ # Market depth proxy (inverse of spread)+ depth_proxy = 1 / spreads.replace(0, np.nan)++ return {+ 'average_depth_proxy': depth_proxy.mean(),+ 'depth_stability': 1 / depth_proxy.std() if depth_proxy.std() > 0 else float('inf'),+ 'thin_market_periods': (spreads > spreads.quantile(0.9)).sum(),+ 'market_quality': 'High' if spreads.mean() < 0.01 else 'Medium' if spreads.mean() < 0.05 else 'Low'+ }+ else:+ return {'error': 'Insufficient data for depth analysis'}++ def analyze_market_liquidity(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Analyze market liquidity characteristics"""++ liquidity_measures = {}++ # Bid-ask spread (tightness)+ if 'Bid' in market_data.columns and 'Ask' in market_data.columns:+ spreads = market_data['Ask'] - market_data['Bid']+ mid_prices = (market_data['Bid'] + market_data['Ask']) / 2+ relative_spreads = spreads / mid_prices++ liquidity_measures['tightness'] = {+ 'average_relative_spread': relative_spreads.mean(),+ 'spread_consistency': 1 / relative_spreads.std() if relative_spreads.std() > 0 else float('inf')+ }++ # Volume-based measures (depth)+ if 'Volume' in market_data.columns:+ liquidity_measures['depth'] = {+ 'average_daily_volume': market_data['Volume'].mean(),+ 'volume_consistency': 1 / market_data['Volume'].std() * market_data['Volume'].mean() if market_data[+ 'Volume'].std() > 0 else float(+ 'inf')+ }++ # Price impact measures (resilience)+ if 'Close' in market_data.columns:+ returns = market_data['Close'].pct_change().dropna()++ liquidity_measures['resilience'] = {+ 'return_volatility': returns.std(),+ 'price_resilience': 1 / returns.std() if returns.std() > 0 else float('inf')+ }++ # Overall liquidity score+ liquidity_score = self.calculate_liquidity_score(liquidity_measures)++ return {+ 'liquidity_measures': liquidity_measures,+ 'overall_liquidity_score': liquidity_score,+ 'liquidity_rating': self.rate_liquidity(liquidity_score)+ }++ def calculate_liquidity_score(self, liquidity_measures: Dict[str, Any]) -> float:+ """Calculate overall liquidity score"""++ score = 0+ factors = 0++ # Tightness component (lower spreads = higher liquidity)+ if 'tightness' in liquidity_measures:+ spread = liquidity_measures['tightness']['average_relative_spread']+ if spread > 0:+ tightness_score = max(0, 1 - spread * 100) # Convert to 0-1 scale+ score += tightness_score+ factors += 1++ # Depth component (higher volume = higher liquidity)+ if 'depth' in liquidity_measures:+ # Normalized volume score (simplified)+ depth_score = 0.7 # Placeholder - would need market benchmarks+ score += depth_score+ factors += 1++ # Resilience component (lower volatility = higher liquidity)+ if 'resilience' in liquidity_measures:+ volatility = liquidity_measures['resilience']['return_volatility']+ if volatility > 0:+ resilience_score = max(0, 1 - volatility * 10) # Simplified scaling+ score += resilience_score+ factors += 1++ return score / factors if factors > 0 else 0++ def rate_liquidity(self, liquidity_score: float) -> str:+ """Rate liquidity based on score"""++ if liquidity_score >= 0.8:+ return "High Liquidity"+ elif liquidity_score >= 0.6:+ return "Medium Liquidity"+ elif liquidity_score >= 0.4:+ return "Low Liquidity"+ else:+ return "Very Low Liquidity"++ def estimate_trading_costs(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Estimate trading costs"""++ trading_costs = {}++ # Bid-ask spread cost+ if 'Bid' in market_data.columns and 'Ask' in market_data.columns:+ spreads = market_data['Ask'] - market_data['Bid']+ mid_prices = (market_data['Bid'] + market_data['Ask']) / 2+ spread_cost = spreads / mid_prices / 2 # Half-spread cost++ trading_costs['bid_ask_cost'] = {+ 'average_spread_cost': spread_cost.mean(),+ 'min_spread_cost': spread_cost.min(),+ 'max_spread_cost': spread_cost.max()+ }++ # Market impact cost estimation (simplified)+ if 'Volume' in market_data.columns and 'Close' in market_data.columns:+ returns = market_data['Close'].pct_change().abs()+ volume = market_data['Volume']++ # Proxy for market impact: higher returns with lower volume suggest higher impact+ impact_proxy = returns / (volume / volume.mean())++ trading_costs['market_impact'] = {+ 'average_impact_proxy': impact_proxy.mean(),+ 'impact_volatility': impact_proxy.std()+ }++ # Total estimated trading cost+ if 'bid_ask_cost' in trading_costs:+ estimated_total_cost = trading_costs['bid_ask_cost']['average_spread_cost']+ if 'market_impact' in trading_costs:+ estimated_total_cost += trading_costs['market_impact']['average_impact_proxy'] * 0.5++ trading_costs['estimated_total_cost'] = estimated_total_cost++ return trading_costs++ def calculate_efficiency_indicators(self, market_data: pd.DataFrame) -> Dict[str, Any]:+ """Calculate market efficiency indicators"""++ if 'Close' not in market_data.columns:+ return {'error': 'Price data required for efficiency analysis'}++ returns = market_data['Close'].pct_change().dropna()++ # Return predictability (lower = more efficient)+ autocorrelation = returns.autocorr(lag=1)++ # Volatility clustering+ squared_returns = returns ** 2+ volatility_clustering = squared_returns.autocorr(lag=1)++ # Price discovery efficiency+ if len(returns) > 20:+ # Variance ratio test (simplified)+ returns_2day = returns.rolling(2).sum().dropna()+ variance_ratio = (returns_2day.var() / 2) / returns.var()+ else:+ variance_ratio = 1++ return {+ 'return_autocorrelation': autocorrelation,+ 'volatility_clustering': volatility_clustering,+ 'variance_ratio': variance_ratio,+ 'efficiency_assessment': self.assess_efficiency(autocorrelation, variance_ratio)+ }++ def assess_efficiency(self, autocorr: float, variance_ratio: float) -> str:+ """Assess market efficiency based on indicators"""++ # Efficient markets should have low autocorrelation and variance ratio near 1+ if abs(autocorr) < 0.05 and abs(variance_ratio - 1) < 0.1:+ return "Highly Efficient"+ elif abs(autocorr) < 0.1 and abs(variance_ratio - 1) < 0.2:+ return "Moderately Efficient"+ else:+ return "Less Efficient"+++class FinancialSystemAnalyzer:+ """Analyze financial system functions and intermediaries"""++ def __init__(self):+ self.intermediary_types = {+ 'commercial_banks': {+ 'primary_function': 'Deposit taking and lending',+ 'services': ['Deposits', 'Loans', 'Payments', 'Credit cards'],+ 'regulation': 'Heavy',+ 'funding_source': 'Deposits'+ },+ 'investment_banks': {+ 'primary_function': 'Capital raising and advisory',+ 'services': ['Underwriting', 'M&A Advisory', 'Trading', 'Research'],+ 'regulation': 'Moderate',+ 'funding_source': 'Proprietary capital'+ },+ 'insurance_companies': {+ 'primary_function': 'Risk transfer and pooling',+ 'services': ['Life insurance', 'Property insurance', 'Annuities'],+ 'regulation': 'Heavy',+ 'funding_source': 'Premiums'+ },+ 'mutual_funds': {+ 'primary_function': 'Pooled investment management',+ 'services': ['Diversification', 'Professional management', 'Liquidity'],+ 'regulation': 'Moderate',+ 'funding_source': 'Investor contributions'+ },+ 'pension_funds': {+ 'primary_function': 'Retirement savings management',+ 'services': ['Long-term investing', 'Retirement planning'],+ 'regulation': 'Heavy',+ 'funding_source': 'Employee/employer contributions'+ }+ }++ def analyze_financial_system_functions(self) -> Dict[str, Any]:+ """Analyze main functions of the financial system"""++ return {+ 'primary_functions': {+ 'capital_allocation': {+ 'description': 'Direct savings to most productive uses',+ 'mechanisms': ['Primary markets', 'Secondary markets', 'Financial intermediaries'],+ 'importance': 'Economic growth and efficiency'+ },+ 'risk_management': {+ 'description': 'Transfer and pool risks',+ 'mechanisms': ['Insurance', 'Derivatives', 'Diversification'],+ 'importance': 'Economic stability and confidence'+ },+ 'liquidity_provision': {+ 'description': 'Convert illiquid assets to liquid form',+ 'mechanisms': ['Secondary markets', 'Financial intermediaries'],+ 'importance': 'Investment flexibility and efficiency'+ },+ 'payment_system': {+ 'description': 'Facilitate exchange of goods and services',+ 'mechanisms': ['Banks', 'Payment processors', 'Central banks'],+ 'importance': 'Economic transactions and commerce'+ },+ 'information_services': {+ 'description': 'Gather and disseminate financial information',+ 'mechanisms': ['Research', 'Rating agencies', 'Financial reporting'],+ 'importance': 'Informed decision making'+ }+ },+ 'system_characteristics': {+ 'well_functioning_indicators': [+ 'Complete markets',+ 'Liquidity',+ 'Transparency',+ 'Low transaction costs',+ 'Regulatory framework'+ ]+ }+ }++ def analyze_intermediary_services(self, intermediary_type: str) -> Dict[str, Any]:+ """Analyze services provided by specific intermediary type"""++ if intermediary_type not in self.intermediary_types:+ return {'error': f'Unknown intermediary type: {intermediary_type}'}++ intermediary_info = self.intermediary_types[intermediary_type]++ return {+ 'intermediary_type': intermediary_type,+ 'characteristics': intermediary_info,+ 'value_proposition': self.determine_value_proposition(intermediary_type),+ 'regulatory_considerations': self.get_regulatory_considerations(intermediary_type)+ }++ def determine_value_proposition(self, intermediary_type: str) -> List[str]:+ """Determine value proposition for intermediary type"""++ value_props = {+ 'commercial_banks': [+ 'Maturity transformation',+ 'Risk pooling',+ 'Transaction cost reduction',+ 'Payment system access'+ ],+ 'investment_banks': [+ 'Capital raising expertise',+ 'Market making',+ 'Information production',+ 'Risk management'+ ],+ 'insurance_companies': [+ 'Risk pooling',+ 'Risk transfer',+ 'Long-term savings',+ 'Actuarial expertise'+ ],+ 'mutual_funds': [+ 'Professional management',+ 'Diversification',+ 'Economies of scale',+ 'Liquidity'+ ],+ 'pension_funds': [+ 'Long-term investing',+ 'Tax advantages',+ 'Professional management',+ 'Retirement planning'+ ]+ }++ return value_props.get(intermediary_type, [])++ def get_regulatory_considerations(self, intermediary_type: str) -> List[str]:+ """Get regulatory considerations for intermediary type"""++ regulations = {+ 'commercial_banks': [+ 'Capital requirements',+ 'Deposit insurance',+ 'Reserve requirements',+ 'Lending restrictions'+ ],+ 'investment_banks': [+ 'Securities regulations',+ 'Capital requirements',+ 'Conduct rules',+ 'Systemic risk oversight'+ ],+ 'insurance_companies': [+ 'Solvency requirements',+ 'Reserve requirements',+ 'Product regulations',+ 'Consumer protection'+ ],+ 'mutual_funds': [+ 'Investment restrictions',+ 'Disclosure requirements',+ 'Valuation rules',+ 'Investor protection'+ ],+ 'pension_funds': [+ 'Fiduciary duties',+ 'Investment restrictions',+ 'Funding requirements',+ 'ERISA compliance'+ ]+ }++ return regulations.get(intermediary_type, [])+++# Convenience functions for quick analysis+def quick_margin_analysis(position_value: float, initial_margin: float = 0.5) -> Dict[str, float]:+ """Quick margin requirement analysis"""+ calculator = MarginTradingCalculator()+ return calculator.calculate_margin_requirements(position_value, initial_margin)+++def calculate_margin_call_price(initial_price: float, loan_amount: float,+ shares: int, maintenance_margin: float = 0.25) -> float:+ """Quick margin call price calculation"""+ calculator = MarginTradingCalculator()+ return calculator.calculate_margin_call_price(initial_price, 0, loan_amount, shares, maintenance_margin)+++def analyze_order_execution(order_type: str, limit_price: float = None,+ current_bid: float = 100, current_ask: float = 101) -> Dict[str, Any]:+ """Quick order analysis"""+ analyzer = OrderAnalyzer()++ # Create mock order+ order = TradingOrder(+ order_type=OrderType(order_type.lower()),+ order_validity=OrderValidity.DAY_ORDER,+ security_symbol="MOCK",+ quantity=100,+ price=limit_price,+ stop_price=None,+ position_type=PositionType.LONG+ )++ if order_type.lower() == 'market_order':+ return analyzer.analyze_market_order(order, current_bid, current_ask)+ elif order_type.lower() == 'limit_order':+ return analyzer.analyze_limit_order(order, (current_bid + current_ask) / 2)+ else:+ return {'error': 'Unsupported order type for quick analysis'}+++def classify_security(security_type: str, **characteristics) -> Dict[str, Any]:+ """Quick security classification"""+ classifier = SecurityClassifier()++ if security_type.lower() in ['stock', 'equity']:+ return classifier.classify_equity_security(characteristics)+ elif security_type.lower() in ['bond', 'debt']:+ return classifier.classify_debt_security(characteristics)+ else:+ return {'error': 'Unsupported security type'}\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/tree b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/treenew file mode 100644index 000000000..e9955722a--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/tree@@ -0,0 +1,42 @@+fincept_terminal/+├── core_analytics/+│ ├── __init__.py+│ ├── base/+│ │ ├── __init__.py+│ │ ├── data_provider.py+│ │ ├── validators.py+│ │ └── base_models.py+│ │+│ ├── equity_valuation/+│ │ ├── __init__.py+│ │ ├── dividend_models.py # DDM, Gordon, H-model, multi-stage+│ │ ├── dcf_models.py # FCFF, FCFE, terminal value+│ │ ├── multiples_valuation.py # All price/EV multiples, comparables+│ │ ├── residual_income.py # RI, EVA, accounting adjustments+│ │ ├── private_valuation.py # Private company methods+│ │ └── advanced_valuation.py # Sum-of-parts, conglomerate discounts+│ │+│ ├── market_analysis/+│ │ ├── __init__.py+│ │ ├── market_efficiency.py # Efficiency tests, anomalies, behavioral+│ │ ├── index_analysis.py # Index construction, rebalancing+│ │ ├── market_structure.py # Trading, orders, margin calculations+│ │ └── securities_analysis.py # Security types, characteristics, risk/return+│ │+│ ├── company_analysis/+│ │ ├── __init__.py+│ │ ├── fundamental_analysis.py # Business model, ratios, DuPont+│ │ ├── industry_analysis.py # Porter's 5 forces, PESTLE, competitive+│ │ ├── forecasting.py # Revenue, expense, scenario modeling+│ │ └── momentum_analysis.py # Momentum indicators for valuation+│ │+│ ├── utils/+│ │ ├── __init__.py+│ │ ├── calculations.py # Financial calculations, normalization+│ │ ├── reporting.py # Reports, cross-border adjustments+│ │ └── config.py # Settings, parameters+│ │+│ └── data_sources/+│ ├── __init__.py+│ ├── provider_factory.py+│ └── manual_input.py\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/utils/calculations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/utils/calculations.pynew file mode 100644index 000000000..62ff9a75d--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/equityInvestment/utils/calculations.py@@ -0,0 +1,671 @@++Equity Investment Calculations Module+======================================++Financial calculations and utility functions++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Market price data and trading volume information+ - Industry reports and competitive analysis data+ - Management guidance and analyst estimates+ - Economic indicators affecting equity markets++OUTPUT:+ - Equity valuation models and fair value estimates+ - Fundamental analysis metrics and financial ratios+ - Investment recommendations and target prices+ - Risk assessments and portfolio implications+ - Sector and industry comparative analysis++PARAMETERS:+ - valuation_method: Primary valuation methodology (default: 'DCF')+ - discount_rate: Discount rate for valuation (default: 0.10)+ - terminal_growth: Terminal growth rate assumption (default: 0.025)+ - earnings_multiple: Target earnings multiple (default: 15.0)+ - reporting_currency: Reporting currency (default: 'USD')+++import numpy as np+import pandas as pd+from typing import List, Dict, Any, Optional, Tuple, Union+import math+from scipy import stats+from scipy.optimize import fsolve+import warnings++from .base_models import ValidationError+++class FinancialCalculations:+ """Common financial calculation utilities"""++ @staticmethod+ def time_value_of_money(principal: float, rate: float, periods: int,+ compounding: str = "annual") -> Dict[str, float]:+ """Comprehensive time value of money calculations"""++ # Compounding frequency mapping+ compounding_freq = {+ "annual": 1,+ "semi-annual": 2,+ "quarterly": 4,+ "monthly": 12,+ "daily": 365,+ "continuous": float('inf')+ }++ freq = compounding_freq.get(compounding.lower(), 1)++ if freq == float('inf'): # Continuous compounding+ future_value = principal * math.exp(rate * periods)+ effective_rate = math.exp(rate) - 1+ else:+ future_value = principal * (1 + rate / freq) ** (freq * periods)+ effective_rate = (1 + rate / freq) ** freq - 1++ present_value = future_value / ((1 + effective_rate) ** periods)++ return {+ 'principal': principal,+ 'future_value': future_value,+ 'present_value_of_fv': present_value,+ 'effective_annual_rate': effective_rate,+ 'total_interest': future_value - principal,+ 'compounding_frequency': freq+ }++ @staticmethod+ def annuity_calculations(payment: float, rate: float, periods: int,+ annuity_type: str = "ordinary") -> Dict[str, float]:+ """Calculate present and future value of annuities"""++ if rate <= 0:+ # Handle zero interest rate case+ pv_annuity = payment * periods+ fv_annuity = payment * periods+ else:+ # Ordinary annuity (payments at end of period)+ pv_ordinary = payment * ((1 - (1 + rate) ** -periods) / rate)+ fv_ordinary = payment * (((1 + rate) ** periods - 1) / rate)++ if annuity_type.lower() == "due":+ # Annuity due (payments at beginning of period)+ pv_annuity = pv_ordinary * (1 + rate)+ fv_annuity = fv_ordinary * (1 + rate)+ else:+ pv_annuity = pv_ordinary+ fv_annuity = fv_ordinary++ return {+ 'payment_amount': payment,+ 'present_value': pv_annuity,+ 'future_value': fv_annuity,+ 'total_payments': payment * periods,+ 'total_interest': fv_annuity - (payment * periods),+ 'annuity_type': annuity_type+ }++ @staticmethod+ def perpetuity_value(payment: float, discount_rate: float,+ growth_rate: float = 0) -> Dict[str, float]:+ """Calculate present value of perpetuity"""++ if discount_rate <= growth_rate:+ raise ValidationError("Discount rate must be greater than growth rate")++ if growth_rate == 0:+ # Simple perpetuity+ pv = payment / discount_rate+ else:+ # Growing perpetuity+ pv = payment / (discount_rate - growth_rate)++ return {+ 'payment': payment,+ 'discount_rate': discount_rate,+ 'growth_rate': growth_rate,+ 'present_value': pv,+ 'perpetuity_type': 'Growing' if growth_rate > 0 else 'Simple'+ }++ @staticmethod+ def loan_calculations(principal: float, annual_rate: float, years: int,+ payment_frequency: int = 12) -> Dict[str, Any]:+ """Calculate loan payments and amortization"""++ monthly_rate = annual_rate / payment_frequency+ total_payments = years * payment_frequency++ if annual_rate == 0:+ payment = principal / total_payments+ else:+ payment = principal * (monthly_rate * (1 + monthly_rate) ** total_payments) / \+ ((1 + monthly_rate) ** total_payments - 1)++ # Create amortization schedule+ balance = principal+ schedule = []+ total_interest = 0++ for i in range(1, int(total_payments) + 1):+ interest_payment = balance * monthly_rate+ principal_payment = payment - interest_payment+ balance -= principal_payment+ total_interest += interest_payment++ schedule.append({+ 'payment_number': i,+ 'payment': payment,+ 'principal': principal_payment,+ 'interest': interest_payment,+ 'balance': max(0, balance) # Avoid negative balance due to rounding+ })++ return {+ 'loan_amount': principal,+ 'monthly_payment': payment,+ 'total_payments': total_payments,+ 'total_interest': total_interest,+ 'total_cost': principal + total_interest,+ 'amortization_schedule': schedule[:12], # First year only+ 'full_schedule_available': True+ }++ @staticmethod+ def bond_calculations(face_value: float, coupon_rate: float, market_rate: float,+ years_to_maturity: float, frequency: int = 2) -> Dict[str, float]:+ """Calculate bond price, yield, and duration"""++ periods = years_to_maturity * frequency+ coupon_payment = (face_value * coupon_rate) / frequency+ period_rate = market_rate / frequency++ # Bond price calculation+ if market_rate == 0:+ bond_price = face_value + (coupon_payment * periods)+ else:+ # Present value of coupon payments+ pv_coupons = coupon_payment * ((1 - (1 + period_rate) ** -periods) / period_rate)+ # Present value of face value+ pv_face = face_value / ((1 + period_rate) ** periods)+ bond_price = pv_coupons + pv_face++ # Current yield+ current_yield = (coupon_payment * frequency) / bond_price++ # Macaulay Duration+ cash_flows = [coupon_payment] * int(periods)+ cash_flows[-1] += face_value # Add face value to last payment++ weighted_time = 0+ total_pv = 0++ for t, cf in enumerate(cash_flows, 1):+ pv_cf = cf / ((1 + period_rate) ** t)+ weighted_time += (t / frequency) * pv_cf+ total_pv += pv_cf++ macaulay_duration = weighted_time / total_pv+ modified_duration = macaulay_duration / (1 + market_rate / frequency)++ return {+ 'bond_price': bond_price,+ 'face_value': face_value,+ 'coupon_rate': coupon_rate,+ 'market_rate': market_rate,+ 'current_yield': current_yield,+ 'macaulay_duration': macaulay_duration,+ 'modified_duration': modified_duration,+ 'price_sensitivity': modified_duration * bond_price * 0.01, # Price change for 1% rate change+ 'premium_discount': 'Premium' if bond_price > face_value else 'Discount' if bond_price < face_value else 'Par'+ }+++class StatisticalCalculations:+ """Statistical analysis utilities for finance"""++ @staticmethod+ def descriptive_statistics(data: Union[List[float], pd.Series]) -> Dict[str, float]:+ """Calculate comprehensive descriptive statistics"""++ if isinstance(data, list):+ data = pd.Series(data)++ return {+ 'count': len(data),+ 'mean': data.mean(),+ 'median': data.median(),+ 'mode': data.mode().iloc[0] if not data.mode().empty else np.nan,+ 'std_dev': data.std(),+ 'variance': data.var(),+ 'skewness': data.skew(),+ 'kurtosis': data.kurtosis(),+ 'min': data.min(),+ 'max': data.max(),+ 'range': data.max() - data.min(),+ 'q25': data.quantile(0.25),+ 'q75': data.quantile(0.75),+ 'iqr': data.quantile(0.75) - data.quantile(0.25),+ 'cv': data.std() / data.mean() if data.mean() != 0 else np.nan+ }++ @staticmethod+ def correlation_analysis(x: Union[List[float], pd.Series],+ y: Union[List[float], pd.Series]) -> Dict[str, float]:+ """Calculate correlation and regression statistics"""++ if isinstance(x, list):+ x = pd.Series(x)+ if isinstance(y, list):+ y = pd.Series(y)++ # Remove missing values+ valid_data = pd.DataFrame({'x': x, 'y': y}).dropna()+ x_clean = valid_data['x']+ y_clean = valid_data['y']++ if len(x_clean) < 2:+ return {'error': 'Insufficient data for correlation analysis'}++ # Correlation+ pearson_corr = x_clean.corr(y_clean)+ spearman_corr = x_clean.corr(y_clean, method='spearman')++ # Linear regression+ slope, intercept, r_value, p_value, std_err = stats.linregress(x_clean, y_clean)++ return {+ 'pearson_correlation': pearson_corr,+ 'spearman_correlation': spearman_corr,+ 'r_squared': r_value ** 2,+ 'regression_slope': slope,+ 'regression_intercept': intercept,+ 'p_value': p_value,+ 'standard_error': std_err,+ 'sample_size': len(x_clean)+ }++ @staticmethod+ def hypothesis_testing(sample_data: Union[List[float], pd.Series],+ null_hypothesis: float, alternative: str = "two-sided",+ alpha: float = 0.05) -> Dict[str, Any]:+ """Perform one-sample t-test"""++ if isinstance(sample_data, list):+ sample_data = pd.Series(sample_data)++ # Remove missing values+ clean_data = sample_data.dropna()++ if len(clean_data) < 2:+ return {'error': 'Insufficient data for hypothesis testing'}++ # One-sample t-test+ t_stat, p_value = stats.ttest_1samp(clean_data, null_hypothesis)++ # Determine if we reject null hypothesis+ if alternative == "two-sided":+ reject_null = p_value < alpha+ elif alternative == "greater":+ reject_null = (t_stat > 0) and (p_value / 2 < alpha)+ elif alternative == "less":+ reject_null = (t_stat < 0) and (p_value / 2 < alpha)+ else:+ reject_null = p_value < alpha++ # Confidence interval+ confidence_level = 1 - alpha+ margin_error = stats.t.ppf((1 + confidence_level) / 2, len(clean_data) - 1) * \+ (clean_data.std() / math.sqrt(len(clean_data)))++ ci_lower = clean_data.mean() - margin_error+ ci_upper = clean_data.mean() + margin_error++ return {+ 'sample_mean': clean_data.mean(),+ 'null_hypothesis': null_hypothesis,+ 't_statistic': t_stat,+ 'p_value': p_value,+ 'alpha': alpha,+ 'reject_null': reject_null,+ 'confidence_interval': (ci_lower, ci_upper),+ 'confidence_level': confidence_level,+ 'sample_size': len(clean_data),+ 'degrees_freedom': len(clean_data) - 1+ }+++class RiskMetrics:+ """Risk and return calculation utilities"""++ @staticmethod+ def portfolio_metrics(returns: Union[List[float], pd.Series],+ risk_free_rate: float = 0.02) -> Dict[str, float]:+ """Calculate comprehensive portfolio risk metrics"""++ if isinstance(returns, list):+ returns = pd.Series(returns)++ # Remove missing values+ returns = returns.dropna()++ if len(returns) == 0:+ return {'error': 'No valid return data'}++ # Basic metrics+ mean_return = returns.mean()+ volatility = returns.std()++ # Risk-adjusted metrics+ sharpe_ratio = (mean_return - risk_free_rate / 252) / volatility if volatility > 0 else 0++ # Downside metrics+ downside_returns = returns[returns < 0]+ downside_deviation = downside_returns.std() if len(downside_returns) > 0 else 0+ sortino_ratio = (mean_return - risk_free_rate / 252) / downside_deviation if downside_deviation > 0 else 0++ # Value at Risk (parametric)+ var_95 = np.percentile(returns, 5)+ var_99 = np.percentile(returns, 1)++ # Expected Shortfall (Conditional VaR)+ es_95 = returns[returns <= var_95].mean() if len(returns[returns <= var_95]) > 0 else var_95+ es_99 = returns[returns <= var_99].mean() if len(returns[returns <= var_99]) > 0 else var_99++ # Maximum Drawdown+ cumulative_returns = (1 + returns).cumprod()+ running_max = cumulative_returns.expanding().max()+ drawdown = (cumulative_returns - running_max) / running_max+ max_drawdown = drawdown.min()++ return {+ 'mean_return': mean_return,+ 'annualized_return': mean_return * 252,+ 'volatility': volatility,+ 'annualized_volatility': volatility * math.sqrt(252),+ 'sharpe_ratio': sharpe_ratio,+ 'sortino_ratio': sortino_ratio,+ 'var_95': var_95,+ 'var_99': var_99,+ 'expected_shortfall_95': es_95,+ 'expected_shortfall_99': es_99,+ 'max_drawdown': max_drawdown,+ 'downside_deviation': downside_deviation,+ 'positive_periods': (returns > 0).sum(),+ 'negative_periods': (returns < 0).sum(),+ 'hit_ratio': (returns > 0).sum() / len(returns)+ }++ @staticmethod+ def beta_calculation(asset_returns: Union[List[float], pd.Series],+ market_returns: Union[List[float], pd.Series]) -> Dict[str, float]:+ """Calculate beta and related risk metrics"""++ if isinstance(asset_returns, list):+ asset_returns = pd.Series(asset_returns)+ if isinstance(market_returns, list):+ market_returns = pd.Series(market_returns)++ # Align series and remove missing values+ combined = pd.DataFrame({'asset': asset_returns, 'market': market_returns}).dropna()++ if len(combined) < 10:+ return {'error': 'Insufficient data for beta calculation'}++ asset_clean = combined['asset']+ market_clean = combined['market']++ # Beta calculation+ covariance = asset_clean.cov(market_clean)+ market_variance = market_clean.var()+ beta = covariance / market_variance if market_variance > 0 else 0++ # Alpha calculation (using CAPM)+ risk_free_rate = 0.02 / 252 # Daily risk-free rate+ alpha = asset_clean.mean() - (risk_free_rate + beta * (market_clean.mean() - risk_free_rate))++ # R-squared+ correlation = asset_clean.corr(market_clean)+ r_squared = correlation ** 2++ # Tracking error+ excess_returns = asset_clean - market_clean+ tracking_error = excess_returns.std()++ # Information ratio+ information_ratio = excess_returns.mean() / tracking_error if tracking_error > 0 else 0++ return {+ 'beta': beta,+ 'alpha': alpha,+ 'correlation': correlation,+ 'r_squared': r_squared,+ 'tracking_error': tracking_error,+ 'information_ratio': information_ratio,+ 'sample_size': len(combined),+ 'annualized_alpha': alpha * 252,+ 'annualized_tracking_error': tracking_error * math.sqrt(252)+ }+++class OptionCalculations:+ """Option pricing and Greeks calculations"""++ @staticmethod+ def black_scholes(spot_price: float, strike_price: float, time_to_expiry: float,+ risk_free_rate: float, volatility: float,+ option_type: str = "call") -> Dict[str, float]:+ """Calculate Black-Scholes option price and Greeks"""++ # Black-Scholes formula components+ d1 = (math.log(spot_price / strike_price) ++ (risk_free_rate + 0.5 * volatility ** 2) * time_to_expiry) / \+ (volatility * math.sqrt(time_to_expiry))++ d2 = d1 - volatility * math.sqrt(time_to_expiry)++ # Standard normal CDF+ N_d1 = stats.norm.cdf(d1)+ N_d2 = stats.norm.cdf(d2)+ N_neg_d1 = stats.norm.cdf(-d1)+ N_neg_d2 = stats.norm.cdf(-d2)++ # Standard normal PDF+ n_d1 = stats.norm.pdf(d1)++ if option_type.lower() == "call":+ # Call option price+ option_price = spot_price * N_d1 - strike_price * math.exp(-risk_free_rate * time_to_expiry) * N_d2++ # Call Greeks+ delta = N_d1+ gamma = n_d1 / (spot_price * volatility * math.sqrt(time_to_expiry))+ theta = (-spot_price * n_d1 * volatility / (2 * math.sqrt(time_to_expiry)) -+ risk_free_rate * strike_price * math.exp(-risk_free_rate * time_to_expiry) * N_d2) / 365++ else: # Put option+ # Put option price+ option_price = strike_price * math.exp(-risk_free_rate * time_to_expiry) * N_neg_d2 - spot_price * N_neg_d1++ # Put Greeks+ delta = N_d1 - 1+ gamma = n_d1 / (spot_price * volatility * math.sqrt(time_to_expiry))+ theta = (-spot_price * n_d1 * volatility / (2 * math.sqrt(time_to_expiry)) ++ risk_free_rate * strike_price * math.exp(-risk_free_rate * time_to_expiry) * N_neg_d2) / 365++ # Greeks common to both calls and puts+ vega = spot_price * n_d1 * math.sqrt(time_to_expiry) / 100 # Per 1% change in volatility+ rho = (strike_price * time_to_expiry * math.exp(-risk_free_rate * time_to_expiry) *+ (N_d2 if option_type.lower() == "call" else N_neg_d2)) / 100 # Per 1% change in rate++ return {+ 'option_price': option_price,+ 'delta': delta,+ 'gamma': gamma,+ 'theta': theta,+ 'vega': vega,+ 'rho': rho,+ 'd1': d1,+ 'd2': d2,+ 'intrinsic_value': max(0, spot_price - strike_price) if option_type.lower() == "call"+ else max(0, strike_price - spot_price),+ 'time_value': option_price - max(0, spot_price - strike_price if option_type.lower() == "call"+ else strike_price - spot_price)+ }++ @staticmethod+ def implied_volatility(option_price: float, spot_price: float, strike_price: float,+ time_to_expiry: float, risk_free_rate: float,+ option_type: str = "call") -> float:+ """Calculate implied volatility using Newton-Raphson method"""++ def bs_price_diff(vol):+ bs_result = OptionCalculations.black_scholes(+ spot_price, strike_price, time_to_expiry, risk_free_rate, vol, option_type+ )+ return bs_result['option_price'] - option_price++ try:+ # Initial guess+ initial_vol = 0.2+ implied_vol = fsolve(bs_price_diff, initial_vol)[0]++ # Validate result+ if implied_vol < 0 or implied_vol > 5: # Unrealistic volatility+ return np.nan++ return implied_vol++ except:+ return np.nan+++class TechnicalIndicators:+ """Technical analysis calculation utilities"""++ @staticmethod+ def moving_averages(prices: Union[List[float], pd.Series],+ periods: List[int]) -> Dict[str, pd.Series]:+ """Calculate multiple moving averages"""++ if isinstance(prices, list):+ prices = pd.Series(prices)++ moving_averages = {}++ for period in periods:+ ma_name = f'MA_{period}'+ moving_averages[ma_name] = prices.rolling(window=period).mean()++ return moving_averages++ @staticmethod+ def bollinger_bands(prices: Union[List[float], pd.Series],+ period: int = 20, std_dev: float = 2) -> Dict[str, pd.Series]:+ """Calculate Bollinger Bands"""++ if isinstance(prices, list):+ prices = pd.Series(prices)++ ma = prices.rolling(window=period).mean()+ std = prices.rolling(window=period).std()++ upper_band = ma + (std * std_dev)+ lower_band = ma - (std * std_dev)++ return {+ 'middle_band': ma,+ 'upper_band': upper_band,+ 'lower_band': lower_band,+ 'bandwidth': (upper_band - lower_band) / ma,+ 'percent_b': (prices - lower_band) / (upper_band - lower_band)+ }++ @staticmethod+ def rsi(prices: Union[List[float], pd.Series], period: int = 14) -> pd.Series:+ """Calculate Relative Strength Index"""++ if isinstance(prices, list):+ prices = pd.Series(prices)++ delta = prices.diff()+ gain = delta.where(delta > 0, 0)+ loss = -delta.where(delta < 0, 0)++ avg_gain = gain.rolling(window=period).mean()+ avg_loss = loss.rolling(window=period).mean()++ rs = avg_gain / avg_loss+ rsi = 100 - (100 / (1 + rs))++ return rsi++ @staticmethod+ def macd(prices: Union[List[float], pd.Series],+ fast_period: int = 12, slow_period: int = 26, signal_period: int = 9) -> Dict[str, pd.Series]:+ """Calculate MACD indicator"""++ if isinstance(prices, list):+ prices = pd.Series(prices)++ ema_fast = prices.ewm(span=fast_period).mean()+ ema_slow = prices.ewm(span=slow_period).mean()++ macd_line = ema_fast - ema_slow+ signal_line = macd_line.ewm(span=signal_period).mean()+ histogram = macd_line - signal_line++ return {+ 'macd_line': macd_line,+ 'signal_line': signal_line,+ 'histogram': histogram+ }+++# Utility functions for common calculations+def quick_return_calculation(start_price: float, end_price: float,+ dividends: float = 0) -> Dict[str, float]:+ """Quick return calculation"""+ price_return = (end_price - start_price) / start_price+ total_return = (end_price - start_price + dividends) / start_price++ return {+ 'price_return': price_return,+ 'total_return': total_return,+ 'dividend_yield': dividends / start_price,+ 'price_appreciation': price_return+ }+++def compound_annual_growth_rate(beginning_value: float, ending_value: float,+ years: float) -> float:+ """Calculate CAGR"""+ if beginning_value <= 0 or ending_value <= 0 or years <= 0:+ raise ValidationError("All values must be positive for CAGR calculation")++ return (ending_value / beginning_value) ** (1 / years) - 1+++def rule_of_72(interest_rate: float) -> float:+ """Calculate doubling time using Rule of 72"""+ if interest_rate <= 0:+ raise ValidationError("Interest rate must be positive")++ return 72 / (interest_rate * 100)+++def effective_annual_rate(nominal_rate: float, compounding_periods: int) -> float:+ """Calculate effective annual rate"""+ return (1 + nominal_rate / compounding_periods) ** compounding_periods - 1+++def present_value_growing_annuity(payment: float, growth_rate: float,+ discount_rate: float, periods: int) -> float:+ """Calculate PV of growing annuity"""+ if discount_rate == growth_rate:+ return payment * periods / (1 + discount_rate)++ factor = (1 - ((1 + growth_rate) / (1 + discount_rate)) ** periods)+ return payment * factor / (discount_rate - growth_rate)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/base_analyzer.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/base_analyzer.pynew file mode 100644index 000000000..5849f37e6--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/base_analyzer.py@@ -0,0 +1,582 @@+"""+Financial Statement Base Analyzer Module+=========================================++Abstract base class providing foundation for all financial statement analyzers with+CFA-compliant methodologies. Ensures consistent analysis framework across all+specialized financial analysis modules with standardized interfaces and validation.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements (10-K, 10-Q filings)+ - Management discussion and analysis (MD&A) sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and comparative company data+ - Economic indicators affecting financial performance++OUTPUT:+ - Standardized financial analysis framework and interfaces+ - Abstract base classes for specialized analyzers+ - Common validation rules and quality checks+ - Consistent reporting templates and formats+ - Integration points for various analysis modules++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - currency_reporting: Reporting currency for analysis (default: 'USD')+ - compliance_standard: Compliance standard (default: 'CFA')+"""++from abc import ABC, abstractmethod+from typing import Dict, List, Optional, Union, Any, Tuple+from dataclasses import dataclass, field+from enum import Enum+import pandas as pd+import numpy as np+from datetime import datetime, date+import logging++# Import from data_processor+from .data_processor import FinancialStatements, CompanyInfo, FinancialPeriod, ReportingStandard+++class AnalysisType(Enum):+ """Types of financial analysis"""+ LIQUIDITY = "liquidity"+ ACTIVITY = "activity"+ SOLVENCY = "solvency"+ PROFITABILITY = "profitability"+ VALUATION = "valuation"+ QUALITY = "quality"+ TECHNICAL = "technical"+ FUNDAMENTAL = "fundamental"+++class RiskLevel(Enum):+ """Risk assessment levels"""+ LOW = "low"+ MODERATE = "moderate"+ HIGH = "high"+ VERY_HIGH = "very_high"+++class TrendDirection(Enum):+ """Trend direction classification"""+ IMPROVING = "improving"+ STABLE = "stable"+ DETERIORATING = "deteriorating"+ VOLATILE = "volatile"+++@dataclass+class AnalysisResult:+ """Standardized analysis result structure"""+ analysis_type: AnalysisType+ metric_name: str+ value: float+ interpretation: str+ risk_level: RiskLevel+ trend: TrendDirection = None+ benchmark_comparison: str = None+ industry_percentile: float = None+ quality_score: float = None+ methodology: str = None+ limitations: List[str] = field(default_factory=list)+ recommendations: List[str] = field(default_factory=list)+++@dataclass+class ComparativeAnalysis:+ """Multi-period or peer comparison results"""+ periods: List[str]+ values: List[float]+ trend_analysis: str+ volatility_measure: float+ growth_rate: float = None+ peer_comparison: Dict[str, float] = field(default_factory=dict)+++@dataclass+class QualityAssessment:+ """Data and earnings quality assessment"""+ overall_score: float # 0-100 scale+ earnings_quality: float+ balance_sheet_quality: float+ cash_flow_quality: float+ red_flags: List[str] = field(default_factory=list)+ warning_signs: List[str] = field(default_factory=list)+ quality_drivers: List[str] = field(default_factory=list)+++class BaseAnalyzer(ABC):+ """+ Abstract base class for all financial statement analyzers.+ Implements CFA Institute analysis framework and best practices.+ """++ def __init__(self, enable_logging: bool = True):+ """Initialize base analyzer with common functionality"""+ self.logger = logging.getLogger(self.__class__.__name__) if enable_logging else None+ self._initialize_benchmarks()+ self._initialize_formulas()++ def _initialize_benchmarks(self):+ """Initialize industry benchmarks and thresholds"""+ # Standard liquidity benchmarks+ self.liquidity_benchmarks = {+ 'current_ratio': {'excellent': 2.0, 'good': 1.5, 'adequate': 1.2, 'poor': 1.0},+ 'quick_ratio': {'excellent': 1.5, 'good': 1.0, 'adequate': 0.8, 'poor': 0.5},+ 'cash_ratio': {'excellent': 0.5, 'good': 0.3, 'adequate': 0.2, 'poor': 0.1}+ }++ # Standard activity benchmarks+ self.activity_benchmarks = {+ 'asset_turnover': {'excellent': 2.0, 'good': 1.5, 'adequate': 1.0, 'poor': 0.5},+ 'inventory_turnover': {'excellent': 12.0, 'good': 8.0, 'adequate': 6.0, 'poor': 4.0},+ 'receivables_turnover': {'excellent': 12.0, 'good': 8.0, 'adequate': 6.0, 'poor': 4.0}+ }++ # Standard solvency benchmarks+ self.solvency_benchmarks = {+ 'debt_to_equity': {'excellent': 0.3, 'good': 0.5, 'adequate': 1.0, 'poor': 2.0},+ 'debt_to_assets': {'excellent': 0.2, 'good': 0.3, 'adequate': 0.5, 'poor': 0.7},+ 'interest_coverage': {'excellent': 10.0, 'good': 5.0, 'adequate': 2.5, 'poor': 1.5}+ }++ # Standard profitability benchmarks+ self.profitability_benchmarks = {+ 'gross_margin': {'excellent': 0.4, 'good': 0.3, 'adequate': 0.2, 'poor': 0.1},+ 'operating_margin': {'excellent': 0.2, 'good': 0.15, 'adequate': 0.1, 'poor': 0.05},+ 'net_margin': {'excellent': 0.15, 'good': 0.1, 'adequate': 0.05, 'poor': 0.02},+ 'roe': {'excellent': 0.2, 'good': 0.15, 'adequate': 0.1, 'poor': 0.05},+ 'roa': {'excellent': 0.15, 'good': 0.1, 'adequate': 0.05, 'poor': 0.02}+ }++ # Quality assessment thresholds+ self.quality_thresholds = {+ 'earnings_quality': {'high': 80, 'moderate': 60, 'low': 40},+ 'cash_flow_quality': {'high': 80, 'moderate': 60, 'low': 40},+ 'balance_sheet_quality': {'high': 80, 'moderate': 60, 'low': 40}+ }++ def _initialize_formulas(self):+ """Initialize standard financial formulas and calculations"""+ # This will be extended by specific analyzers+ self.formula_registry = {}++ @abstractmethod+ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Main analysis method - must be implemented by subclasses++ Args:+ statements: Current period financial statements+ comparative_data: Historical data for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results+ """+ pass++ @abstractmethod+ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key metrics calculated by this analyzer"""+ pass++ def validate_data_sufficiency(self, statements: FinancialStatements,+ required_fields: List[str]) -> Tuple[bool, List[str]]:+ """+ Validate that required data fields are present for analysis++ Args:+ statements: Financial statements to validate+ required_fields: List of required field names++ Returns:+ Tuple of (is_sufficient, missing_fields)+ """+ missing_fields = []++ # Check across all statement types+ all_data = {+ **statements.income_statement,+ **statements.balance_sheet,+ **statements.cash_flow+ }++ for field in required_fields:+ if field not in all_data or all_data[field] is None:+ missing_fields.append(field)++ is_sufficient = len(missing_fields) == 0++ if not is_sufficient and self.logger:+ self.logger.warning(f"Missing required fields for analysis: {missing_fields}")++ return is_sufficient, missing_fields++ def calculate_trend(self, values: List[float], periods: List[str]) -> ComparativeAnalysis:+ """+ Calculate trend analysis for a series of values++ Args:+ values: List of metric values over time+ periods: List of period identifiers++ Returns:+ ComparativeAnalysis object with trend information+ """+ if len(values) < 2:+ return ComparativeAnalysis(+ periods=periods,+ values=values,+ trend_analysis="Insufficient data for trend analysis",+ volatility_measure=0.0+ )++ # Calculate growth rate (CAGR if multiple periods)+ if len(values) > 1:+ if values[0] != 0:+ if len(values) == 2:+ growth_rate = (values[-1] / values[0]) - 1+ else:+ n_periods = len(values) - 1+ growth_rate = (values[-1] / values[0]) ** (1 / n_periods) - 1+ else:+ growth_rate = None+ else:+ growth_rate = None++ # Calculate volatility (coefficient of variation)+ mean_value = np.mean(values)+ std_value = np.std(values)+ volatility = std_value / mean_value if mean_value != 0 else 0++ # Determine trend direction+ if len(values) >= 3:+ recent_trend = np.polyfit(range(len(values)), values, 1)[0]+ if recent_trend > 0.05 * mean_value:+ trend_description = "Strong upward trend"+ elif recent_trend > 0.02 * mean_value:+ trend_description = "Moderate upward trend"+ elif recent_trend < -0.05 * mean_value:+ trend_description = "Strong downward trend"+ elif recent_trend < -0.02 * mean_value:+ trend_description = "Moderate downward trend"+ else:+ trend_description = "Stable trend"+ else:+ if values[-1] > values[0]:+ trend_description = "Improving"+ elif values[-1] < values[0]:+ trend_description = "Declining"+ else:+ trend_description = "Stable"++ return ComparativeAnalysis(+ periods=periods,+ values=values,+ trend_analysis=trend_description,+ volatility_measure=volatility,+ growth_rate=growth_rate+ )++ def assess_risk_level(self, metric_value: float, benchmark_dict: Dict[str, float],+ higher_is_better: bool = True) -> RiskLevel:+ """+ Assess risk level based on metric value and benchmarks++ Args:+ metric_value: The calculated metric value+ benchmark_dict: Dictionary with benchmark thresholds+ higher_is_better: Whether higher values indicate better performance++ Returns:+ RiskLevel enum value+ """+ if higher_is_better:+ if metric_value >= benchmark_dict.get('excellent', float('inf')):+ return RiskLevel.LOW+ elif metric_value >= benchmark_dict.get('good', float('inf')):+ return RiskLevel.LOW+ elif metric_value >= benchmark_dict.get('adequate', float('inf')):+ return RiskLevel.MODERATE+ else:+ return RiskLevel.HIGH+ else:+ if metric_value <= benchmark_dict.get('excellent', 0):+ return RiskLevel.LOW+ elif metric_value <= benchmark_dict.get('good', 0):+ return RiskLevel.LOW+ elif metric_value <= benchmark_dict.get('adequate', float('inf')):+ return RiskLevel.MODERATE+ else:+ return RiskLevel.HIGH++ def generate_interpretation(self, metric_name: str, value: float,+ risk_level: RiskLevel, analysis_type: AnalysisType) -> str:+ """+ Generate standardized interpretation text for metrics++ Args:+ metric_name: Name of the metric+ value: Calculated value+ risk_level: Assessed risk level+ analysis_type: Type of analysis++ Returns:+ Interpretation string+ """+ risk_descriptions = {+ RiskLevel.LOW: "strong",+ RiskLevel.MODERATE: "adequate",+ RiskLevel.HIGH: "weak",+ RiskLevel.VERY_HIGH: "very weak"+ }++ base_interpretation = f"The {metric_name} of {value:.3f} indicates {risk_descriptions[risk_level]} {analysis_type.value} performance."++ # Add specific insights based on metric type+ if analysis_type == AnalysisType.LIQUIDITY:+ if risk_level == RiskLevel.LOW:+ base_interpretation += " The company appears well-positioned to meet short-term obligations."+ elif risk_level == RiskLevel.HIGH:+ base_interpretation += " The company may face challenges meeting short-term obligations."++ elif analysis_type == AnalysisType.PROFITABILITY:+ if risk_level == RiskLevel.LOW:+ base_interpretation += " The company demonstrates effective management and competitive positioning."+ elif risk_level == RiskLevel.HIGH:+ base_interpretation += " The company may need to improve operational efficiency or pricing strategies."++ elif analysis_type == AnalysisType.SOLVENCY:+ if risk_level == RiskLevel.LOW:+ base_interpretation += " The company maintains conservative financial leverage."+ elif risk_level == RiskLevel.HIGH:+ base_interpretation += " The company carries significant financial risk due to high leverage."++ return base_interpretation++ def compare_to_industry(self, metric_value: float, industry_data: Optional[Dict]) -> Optional[str]:+ """+ Compare metric to industry benchmarks++ Args:+ metric_value: Company metric value+ industry_data: Industry benchmark data++ Returns:+ Comparison interpretation or None if no data available+ """+ if not industry_data:+ return None++ industry_median = industry_data.get('median')+ industry_q1 = industry_data.get('q1')+ industry_q3 = industry_data.get('q3')++ if not all([industry_median, industry_q1, industry_q3]):+ return None++ if metric_value >= industry_q3:+ return f"Above industry 75th percentile (Industry median: {industry_median:.3f})"+ elif metric_value >= industry_median:+ return f"Above industry median (Industry median: {industry_median:.3f})"+ elif metric_value >= industry_q1:+ return f"Below industry median but above 25th percentile (Industry median: {industry_median:.3f})"+ else:+ return f"Below industry 25th percentile (Industry median: {industry_median:.3f})"++ def calculate_percentile_rank(self, value: float, peer_values: List[float]) -> float:+ """Calculate percentile rank against peer group"""+ if not peer_values:+ return None++ rank = sum(1 for x in peer_values if x < value)+ percentile = (rank / len(peer_values)) * 100+ return percentile++ def assess_data_quality(self, statements: FinancialStatements,+ required_fields: List[str]) -> QualityAssessment:+ """+ Assess the quality of financial data for analysis++ Args:+ statements: Financial statements to assess+ required_fields: Fields required for specific analysis++ Returns:+ QualityAssessment object+ """+ quality_issues = []+ warning_signs = []+ quality_drivers = []++ # Check data completeness+ all_data = {+ **statements.income_statement,+ **statements.balance_sheet,+ **statements.cash_flow+ }++ missing_critical = [field for field in required_fields if field not in all_data]+ if missing_critical:+ quality_issues.append(f"Missing critical fields: {missing_critical}")++ # Check for negative values where inappropriate+ negative_checks = {+ 'revenue': statements.income_statement.get('revenue', 0),+ 'total_assets': statements.balance_sheet.get('total_assets', 0),+ 'cash_equivalents': statements.balance_sheet.get('cash_equivalents', 0)+ }++ for field, value in negative_checks.items():+ if value < 0:+ warning_signs.append(f"Negative {field}: {value}")++ # Check balance sheet equation+ assets = statements.balance_sheet.get('total_assets', 0)+ liabilities = statements.balance_sheet.get('total_liabilities', 0)+ equity = statements.balance_sheet.get('total_equity', 0)++ if abs(assets - (liabilities + equity)) > 0.01:+ quality_issues.append("Balance sheet equation does not balance")+ else:+ quality_drivers.append("Balance sheet equation balances correctly")++ # Check for unusual relationships+ current_assets = statements.balance_sheet.get('current_assets', 0)+ if current_assets > assets:+ warning_signs.append("Current assets exceed total assets")++ # Assess audit quality indicators+ if statements.period_info.audit_status == 'audited':+ quality_drivers.append("Financial statements are audited")+ elif statements.period_info.audit_status == 'unaudited':+ warning_signs.append("Financial statements are unaudited")++ # Calculate overall quality scores+ earnings_quality = max(0, 100 - len(quality_issues) * 20 - len(warning_signs) * 10)+ balance_sheet_quality = max(0, 100 - len(quality_issues) * 15 - len(warning_signs) * 8)+ cash_flow_quality = max(0, 100 - len(quality_issues) * 25 - len(warning_signs) * 12)++ overall_score = np.mean([earnings_quality, balance_sheet_quality, cash_flow_quality])++ return QualityAssessment(+ overall_score=overall_score,+ earnings_quality=earnings_quality,+ balance_sheet_quality=balance_sheet_quality,+ cash_flow_quality=cash_flow_quality,+ red_flags=quality_issues,+ warning_signs=warning_signs,+ quality_drivers=quality_drivers+ )++ def safe_divide(self, numerator: float, denominator: float, default: float = 0.0) -> float:+ """+ Safely perform division with handling for zero denominators++ Args:+ numerator: Numerator value+ denominator: Denominator value+ default: Default value to return if denominator is zero++ Returns:+ Division result or default value+ """+ if denominator == 0 or denominator is None:+ return default+ return numerator / denominator++ def format_percentage(self, value: float, decimal_places: int = 1) -> str:+ """Format decimal as percentage string"""+ return f"{value * 100:.{decimal_places}f}%"++ def format_ratio(self, value: float, decimal_places: int = 2) -> str:+ """Format ratio with specified decimal places"""+ return f"{value:.{decimal_places}f}"++ def get_analysis_limitations(self, statements: FinancialStatements) -> List[str]:+ """+ Identify general limitations that apply to the analysis++ Args:+ statements: Financial statements being analyzed++ Returns:+ List of limitation descriptions+ """+ limitations = []++ # Check reporting standard limitations+ if statements.company_info.reporting_standard == ReportingStandard.LOCAL_GAAP:+ limitations.append("Analysis based on local GAAP may not be comparable to IFRS or US GAAP companies")++ # Check data age+ period_end = statements.period_info.period_end+ days_old = (datetime.now().date() - period_end).days+ if days_old > 365:+ limitations.append(f"Financial data is {days_old} days old and may not reflect current conditions")++ # Check interim vs annual data+ if statements.period_info.period_type != 'annual':+ limitations.append("Analysis based on interim data may not reflect full-year performance")++ # Check audit status+ if statements.period_info.audit_status == 'unaudited':+ limitations.append("Unaudited financial statements may contain errors or adjustments")++ # Check data quality+ if statements.data_quality.get('completeness_score', 1.0) < 0.8:+ limitations.append("Incomplete financial data may affect analysis accuracy")++ return limitations++ def generate_recommendations(self, analysis_results: List[AnalysisResult]) -> List[str]:+ """+ Generate actionable recommendations based on analysis results++ Args:+ analysis_results: List of analysis results++ Returns:+ List of recommendation strings+ """+ recommendations = []++ # Analyze risk patterns+ high_risk_areas = [result for result in analysis_results+ if result.risk_level in [RiskLevel.HIGH, RiskLevel.VERY_HIGH]]++ if high_risk_areas:+ for area in high_risk_areas:+ if area.analysis_type == AnalysisType.LIQUIDITY:+ recommendations.append(+ "Consider improving working capital management or securing additional credit facilities")+ elif area.analysis_type == AnalysisType.SOLVENCY:+ recommendations.append("Focus on debt reduction and improving interest coverage ratios")+ elif area.analysis_type == AnalysisType.PROFITABILITY:+ recommendations.append("Review cost structure and pricing strategies to improve profitability")+ elif area.analysis_type == AnalysisType.ACTIVITY:+ recommendations.append("Optimize asset utilization and working capital efficiency")++ # Look for declining trends+ declining_trends = [result for result in analysis_results+ if result.trend == TrendDirection.DETERIORATING]++ if declining_trends:+ recommendations.append("Monitor declining performance trends and develop corrective action plans")++ # Quality-based recommendations+ quality_issues = [result for result in analysis_results+ if result.quality_score and result.quality_score < 60]++ if quality_issues:+ recommendations.append("Improve financial reporting quality and transparency")++ return list(set(recommendations)) # Remove duplicates\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/data_processor.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/data_processor.pynew file mode 100644index 000000000..60bb6f445--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/data_processor.py@@ -0,0 +1,525 @@++"""+Financial Statement Data Processor Module+========================================++Financial data processing and standardization for analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import pandas as pd+import numpy as np+from typing import Dict, List, Optional, Union, Any+from datetime import datetime, date+from dataclasses import dataclass, field+from enum import Enum+import logging+++class ReportingStandard(Enum):+ """Financial reporting standards"""+ IFRS = "IFRS"+ US_GAAP = "US_GAAP"+ LOCAL_GAAP = "LOCAL_GAAP"+++class CurrencyType(Enum):+ """Currency classification for multinational operations"""+ PRESENTATION = "presentation" # Reporting currency+ FUNCTIONAL = "functional" # Primary economic environment+ LOCAL = "local" # Local country currency+++class DataSource(Enum):+ """Supported data sources"""+ API = "api"+ CSV = "csv"+ EXCEL = "excel"+ JSON = "json"+ MANUAL = "manual"+ TERMINAL = "terminal"+++@dataclass+class CompanyInfo:+ """Company identification and basic information"""+ ticker: str+ name: str+ sector: str+ industry: str+ country: str+ reporting_standard: ReportingStandard+ fiscal_year_end: str+ presentation_currency: str+ functional_currency: str = None+ exchange: str = None+ market_cap: float = None+++@dataclass+class FinancialPeriod:+ """Financial reporting period information"""+ period_end: date+ period_type: str # 'annual', 'quarterly', 'interim'+ fiscal_year: int+ fiscal_period: str # 'Q1', 'Q2', 'Q3', 'Q4', 'FY'+ reporting_date: date = None+ audit_status: str = None # 'audited', 'reviewed', 'unaudited'+++@dataclass+class FinancialStatements:+ """Standardized financial statement data structure"""+ # Company and period info+ company_info: CompanyInfo+ period_info: FinancialPeriod++ # Income Statement+ income_statement: Dict[str, float] = field(default_factory=dict)++ # Balance Sheet+ balance_sheet: Dict[str, float] = field(default_factory=dict)++ # Cash Flow Statement+ cash_flow: Dict[str, float] = field(default_factory=dict)++ # Statement of Equity+ equity_statement: Dict[str, float] = field(default_factory=dict)++ # Notes and supplementary information+ notes: Dict[str, Any] = field(default_factory=dict)++ # Ratios and metrics (calculated)+ ratios: Dict[str, float] = field(default_factory=dict)++ # Data quality indicators+ data_quality: Dict[str, Any] = field(default_factory=dict)+++class DataProcessor:+ """+ Universal financial data processor supporting multiple data sources and formats.+ Ensures CFA-compliant standardization and validation.+ """++ def __init__(self):+ self.logger = logging.getLogger(__name__)+ self._initialize_standard_mappings()++ def _initialize_standard_mappings(self):+ """Initialize standard account mappings for different reporting standards"""++ # Income Statement Standard Mappings+ self.income_statement_mapping = {+ 'revenue': ['revenue', 'sales', 'net_sales', 'total_revenue', 'net_revenue'],+ 'cost_of_sales': ['cost_of_sales', 'cost_of_goods_sold', 'cogs', 'cost_of_revenue'],+ 'gross_profit': ['gross_profit', 'gross_income'],+ 'operating_expenses': ['operating_expenses', 'total_operating_expenses'],+ 'selling_expenses': ['selling_expenses', 'sales_expenses', 'marketing_expenses'],+ 'administrative_expenses': ['administrative_expenses', 'admin_expenses', 'general_admin'],+ 'rd_expenses': ['research_development', 'rd_expenses', 'r_and_d'],+ 'depreciation': ['depreciation', 'depreciation_amortization', 'da_expense'],+ 'operating_income': ['operating_income', 'ebit', 'operating_profit'],+ 'interest_expense': ['interest_expense', 'interest_cost', 'finance_costs'],+ 'interest_income': ['interest_income', 'interest_revenue'],+ 'other_income': ['other_income', 'other_revenue', 'non_operating_income'],+ 'pretax_income': ['pretax_income', 'ebt', 'income_before_tax'],+ 'tax_expense': ['tax_expense', 'income_tax', 'provision_for_taxes'],+ 'net_income': ['net_income', 'net_profit', 'profit_after_tax'],+ 'discontinued_operations': ['discontinued_operations', 'discontinued_ops'],+ 'extraordinary_items': ['extraordinary_items', 'exceptional_items'],+ 'basic_eps': ['basic_eps', 'earnings_per_share_basic'],+ 'diluted_eps': ['diluted_eps', 'earnings_per_share_diluted'],+ 'shares_outstanding_basic': ['shares_outstanding_basic', 'basic_shares'],+ 'shares_outstanding_diluted': ['shares_outstanding_diluted', 'diluted_shares']+ }++ # Balance Sheet Standard Mappings+ self.balance_sheet_mapping = {+ # Assets+ 'cash_equivalents': ['cash', 'cash_equivalents', 'cash_and_equivalents'],+ 'short_term_investments': ['short_term_investments', 'marketable_securities'],+ 'accounts_receivable': ['accounts_receivable', 'receivables', 'trade_receivables'],+ 'inventory': ['inventory', 'inventories'],+ 'prepaid_expenses': ['prepaid_expenses', 'prepaid_assets'],+ 'current_assets': ['current_assets', 'total_current_assets'],+ 'ppe_gross': ['ppe_gross', 'property_plant_equipment_gross'],+ 'accumulated_depreciation': ['accumulated_depreciation', 'accum_depreciation'],+ 'ppe_net': ['ppe_net', 'property_plant_equipment_net'],+ 'intangible_assets': ['intangible_assets', 'intangibles'],+ 'goodwill': ['goodwill'],+ 'long_term_investments': ['long_term_investments', 'investments'],+ 'total_assets': ['total_assets', 'assets'],++ # Liabilities+ 'accounts_payable': ['accounts_payable', 'payables', 'trade_payables'],+ 'short_term_debt': ['short_term_debt', 'current_debt'],+ 'accrued_liabilities': ['accrued_liabilities', 'accrued_expenses'],+ 'current_liabilities': ['current_liabilities', 'total_current_liabilities'],+ 'long_term_debt': ['long_term_debt', 'non_current_debt'],+ 'deferred_tax_liability': ['deferred_tax_liability', 'deferred_tax_liab'],+ 'other_liabilities': ['other_liabilities', 'other_non_current_liab'],+ 'total_liabilities': ['total_liabilities', 'liabilities'],++ # Equity+ 'common_stock': ['common_stock', 'share_capital'],+ 'retained_earnings': ['retained_earnings'],+ 'accumulated_oci': ['accumulated_oci', 'other_comprehensive_income'],+ 'treasury_stock': ['treasury_stock', 'treasury_shares'],+ 'total_equity': ['total_equity', 'shareholders_equity', 'stockholders_equity']+ }++ # Cash Flow Statement Standard Mappings+ self.cash_flow_mapping = {+ # Operating Activities+ 'net_income_cf': ['net_income', 'profit_after_tax'],+ 'depreciation_cf': ['depreciation', 'depreciation_amortization'],+ 'amortization_cf': ['amortization'],+ 'stock_compensation': ['stock_based_compensation', 'share_based_comp'],+ 'deferred_tax': ['deferred_tax', 'deferred_tax_expense'],+ 'working_capital_change': ['working_capital_change', 'change_working_capital'],+ 'accounts_receivable_change': ['accounts_receivable_change'],+ 'inventory_change': ['inventory_change'],+ 'accounts_payable_change': ['accounts_payable_change'],+ 'operating_cash_flow': ['operating_cash_flow', 'cash_from_operations'],++ # Investing Activities+ 'capex': ['capital_expenditures', 'capex', 'ppe_investments'],+ 'acquisitions': ['acquisitions', 'business_acquisitions'],+ 'asset_sales': ['asset_sales', 'asset_disposals'],+ 'investment_purchases': ['investment_purchases', 'securities_purchased'],+ 'investment_sales': ['investment_sales', 'securities_sold'],+ 'investing_cash_flow': ['investing_cash_flow', 'cash_from_investing'],++ # Financing Activities+ 'debt_issued': ['debt_issued', 'debt_proceeds'],+ 'debt_repaid': ['debt_repaid', 'debt_repayments'],+ 'equity_issued': ['equity_issued', 'stock_issued'],+ 'equity_repurchased': ['equity_repurchased', 'stock_repurchased'],+ 'dividends_paid': ['dividends_paid', 'dividend_payments'],+ 'financing_cash_flow': ['financing_cash_flow', 'cash_from_financing'],++ # Net Change+ 'net_cash_change': ['net_cash_change', 'net_change_cash'],+ 'cash_beginning': ['cash_beginning_period', 'beginning_cash'],+ 'cash_ending': ['cash_ending_period', 'ending_cash']+ }++ def process_data(self, data: Union[Dict, pd.DataFrame, str],+ source_type: DataSource,+ company_info: CompanyInfo,+ period_info: FinancialPeriod) -> FinancialStatements:+ """+ Main entry point for processing financial data from any source++ Args:+ data: Raw financial data+ source_type: Type of data source+ company_info: Company identification information+ period_info: Financial period information++ Returns:+ FinancialStatements: Standardized financial statement object+ """+ try:+ # Load data based on source type+ raw_data = self._load_data(data, source_type)++ # Validate data structure+ self._validate_raw_data(raw_data)++ # Standardize account names and structure+ standardized_data = self._standardize_accounts(raw_data)++ # Create financial statements object+ statements = FinancialStatements(+ company_info=company_info,+ period_info=period_info+ )++ # Populate statement sections+ statements.income_statement = self._extract_income_statement(standardized_data)+ statements.balance_sheet = self._extract_balance_sheet(standardized_data)+ statements.cash_flow = self._extract_cash_flow(standardized_data)+ statements.equity_statement = self._extract_equity_statement(standardized_data)+ statements.notes = self._extract_notes(standardized_data)++ # Perform data quality assessment+ statements.data_quality = self._assess_data_quality(statements)++ # Validate financial statement integrity+ self._validate_financial_statements(statements)++ self.logger.info(f"Successfully processed data for {company_info.ticker} - {period_info.period_end}")+ return statements++ except Exception as e:+ self.logger.error(f"Error processing data: {str(e)}")+ raise++ def _load_data(self, data: Union[Dict, pd.DataFrame, str], source_type: DataSource) -> Dict:+ """Load data from various sources"""+ if source_type == DataSource.CSV:+ if isinstance(data, str):+ df = pd.read_csv(data)+ else:+ df = data+ return df.to_dict('records')[0] if len(df) == 1 else df.to_dict('list')++ elif source_type == DataSource.EXCEL:+ if isinstance(data, str):+ df = pd.read_excel(data)+ else:+ df = data+ return df.to_dict('records')[0] if len(df) == 1 else df.to_dict('list')++ elif source_type == DataSource.JSON:+ if isinstance(data, str):+ import json+ with open(data, 'r') as f:+ return json.load(f)+ return data++ elif source_type in [DataSource.API, DataSource.TERMINAL, DataSource.MANUAL]:+ return data if isinstance(data, dict) else data.to_dict()++ else:+ raise ValueError(f"Unsupported source type: {source_type}")++ def _standardize_accounts(self, raw_data: Dict) -> Dict:+ """Standardize account names using mapping dictionaries"""+ standardized = {}++ # Convert all keys to lowercase for matching+ raw_lower = {k.lower().replace(' ', '_').replace('-', '_'): v+ for k, v in raw_data.items()}++ # Apply mappings for each statement type+ all_mappings = {+ **self.income_statement_mapping,+ **self.balance_sheet_mapping,+ **self.cash_flow_mapping+ }++ for standard_name, possible_names in all_mappings.items():+ for possible_name in possible_names:+ if possible_name.lower() in raw_lower:+ standardized[standard_name] = raw_lower[possible_name.lower()]+ break++ # Add any unmapped accounts with original names+ for orig_key, value in raw_lower.items():+ if not any(orig_key in mapping for mapping in all_mappings.values()):+ standardized[orig_key] = value++ return standardized++ def _extract_income_statement(self, data: Dict) -> Dict[str, float]:+ """Extract and organize income statement items"""+ income_items = {}++ for key in self.income_statement_mapping.keys():+ if key in data:+ income_items[key] = float(data[key]) if data[key] is not None else 0.0++ # Calculate derived items if not present+ if 'gross_profit' not in income_items and 'revenue' in income_items and 'cost_of_sales' in income_items:+ income_items['gross_profit'] = income_items['revenue'] - income_items['cost_of_sales']++ if 'operating_income' not in income_items and 'gross_profit' in income_items and 'operating_expenses' in income_items:+ income_items['operating_income'] = income_items['gross_profit'] - income_items['operating_expenses']++ return income_items++ def _extract_balance_sheet(self, data: Dict) -> Dict[str, float]:+ """Extract and organize balance sheet items"""+ balance_items = {}++ for key in self.balance_sheet_mapping.keys():+ if key in data:+ balance_items[key] = float(data[key]) if data[key] is not None else 0.0++ return balance_items++ def _extract_cash_flow(self, data: Dict) -> Dict[str, float]:+ """Extract and organize cash flow statement items"""+ cf_items = {}++ for key in self.cash_flow_mapping.keys():+ if key in data:+ cf_items[key] = float(data[key]) if data[key] is not None else 0.0++ return cf_items++ def _extract_equity_statement(self, data: Dict) -> Dict[str, float]:+ """Extract equity statement information"""+ equity_items = {}++ # Extract equity-related items+ equity_keys = ['common_stock', 'retained_earnings', 'accumulated_oci', 'treasury_stock']+ for key in equity_keys:+ if key in data:+ equity_items[key] = float(data[key]) if data[key] is not None else 0.0++ return equity_items++ def _extract_notes(self, data: Dict) -> Dict[str, Any]:+ """Extract notes and supplementary information"""+ notes = {}++ # Look for note-related information+ note_keywords = ['accounting_policy', 'segment', 'geographic', 'related_party',+ 'contingency', 'commitment', 'subsequent_event']++ for key, value in data.items():+ if any(keyword in key.lower() for keyword in note_keywords):+ notes[key] = value++ return notes++ def _validate_raw_data(self, data: Dict):+ """Validate raw data structure and completeness"""+ if not data:+ raise ValueError("Empty data provided")++ # Check for minimum required fields+ required_fields = ['revenue', 'total_assets', 'total_equity']+ missing_fields = []++ data_lower = {k.lower(): v for k, v in data.items()}++ for field in required_fields:+ field_found = False+ if field in self.income_statement_mapping:+ for possible_name in self.income_statement_mapping[field]:+ if possible_name.lower() in data_lower:+ field_found = True+ break+ elif field in self.balance_sheet_mapping:+ for possible_name in self.balance_sheet_mapping[field]:+ if possible_name.lower() in data_lower:+ field_found = True+ break++ if not field_found:+ missing_fields.append(field)++ if missing_fields:+ self.logger.warning(f"Missing recommended fields: {missing_fields}")++ def _validate_financial_statements(self, statements: FinancialStatements):+ """Validate financial statement integrity and relationships"""+ errors = []+ warnings = []++ # Balance Sheet Equation: Assets = Liabilities + Equity+ if statements.balance_sheet:+ assets = statements.balance_sheet.get('total_assets', 0)+ liabilities = statements.balance_sheet.get('total_liabilities', 0)+ equity = statements.balance_sheet.get('total_equity', 0)++ if abs(assets - (liabilities + equity)) > 0.01: # Allow for rounding+ errors.append(+ f"Balance sheet doesn't balance: Assets({assets}) != Liabilities({liabilities}) + Equity({equity})")++ # Cash Flow Statement: Net change should equal ending - beginning cash+ if statements.cash_flow:+ net_change = statements.cash_flow.get('net_cash_change', 0)+ beginning = statements.cash_flow.get('cash_beginning', 0)+ ending = statements.cash_flow.get('cash_ending', 0)++ if abs(net_change - (ending - beginning)) > 0.01:+ warnings.append("Cash flow net change doesn't match beginning/ending cash difference")++ # EPS consistency check+ if statements.income_statement:+ net_income = statements.income_statement.get('net_income', 0)+ basic_eps = statements.income_statement.get('basic_eps', 0)+ basic_shares = statements.income_statement.get('shares_outstanding_basic', 0)++ if basic_eps and basic_shares and abs(basic_eps - (net_income / basic_shares)) > 0.01:+ warnings.append("Basic EPS calculation inconsistent with net income and shares outstanding")++ statements.data_quality['validation_errors'] = errors+ statements.data_quality['validation_warnings'] = warnings++ if errors:+ raise ValueError(f"Financial statement validation failed: {errors}")++ def _assess_data_quality(self, statements: FinancialStatements) -> Dict[str, Any]:+ """Assess data quality and completeness"""+ quality_metrics = {+ 'completeness_score': 0.0,+ 'consistency_score': 0.0,+ 'missing_fields': [],+ 'data_issues': []+ }++ # Assess completeness+ total_expected_fields = len(self.income_statement_mapping) + len(self.balance_sheet_mapping) + len(+ self.cash_flow_mapping)+ total_present_fields = len(statements.income_statement) + len(statements.balance_sheet) + len(+ statements.cash_flow)++ quality_metrics['completeness_score'] = min(total_present_fields / total_expected_fields, 1.0)++ # Identify missing critical fields+ critical_fields = ['revenue', 'net_income', 'total_assets', 'total_equity', 'operating_cash_flow']+ for field in critical_fields:+ if field not in statements.income_statement and field not in statements.balance_sheet and field not in statements.cash_flow:+ quality_metrics['missing_fields'].append(field)++ # Assess consistency (basic checks)+ consistency_checks = 0+ passed_checks = 0++ # Check if current assets <= total assets+ if statements.balance_sheet.get('current_assets', 0) <= statements.balance_sheet.get('total_assets', 0):+ passed_checks += 1+ consistency_checks += 1++ # Check if revenue > 0 for operating companies+ if statements.income_statement.get('revenue', 0) > 0:+ passed_checks += 1+ consistency_checks += 1++ quality_metrics['consistency_score'] = passed_checks / consistency_checks if consistency_checks > 0 else 0.0++ return quality_metrics++ def convert_currency(self, statements: FinancialStatements,+ target_currency: str,+ exchange_rates: Dict[str, float]) -> FinancialStatements:+ """Convert financial statements to target currency"""+ # This is a placeholder for currency conversion functionality+ # In practice, this would handle translation methods (current rate vs temporal)+ # and multinational operations as per CFA Level II curriculum+ pass++ def adjust_for_inflation(self, statements: FinancialStatements,+ inflation_rate: float) -> FinancialStatements:+ """Adjust financial statements for inflation (hyperinflationary economies)"""+ # Placeholder for inflation adjustment methods+ pass\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/asset_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/asset_analysis.pynew file mode 100644index 000000000..6ee077a83--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/asset_analysis.py@@ -0,0 +1,31 @@++"""+Financial Statement Asset Analysis Module+========================================++Asset-specific analysis and valuation methodologies++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/employee_compensation.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/employee_compensation.pynew file mode 100644index 000000000..9a28279ab--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/employee_compensation.py@@ -0,0 +1,988 @@++"""+Financial Statement Employee Compensation Module+========================================++Employee compensation analysis and impact assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class CompensationType(Enum):+ """Types of employee compensation"""+ CASH_WAGES = "cash_wages_salaries"+ POST_EMPLOYMENT = "post_employment_benefits"+ SHARE_BASED = "share_based_compensation"+ OTHER_BENEFITS = "other_employee_benefits"+++class PensionPlanType(Enum):+ """Types of pension plans"""+ DEFINED_CONTRIBUTION = "defined_contribution"+ DEFINED_BENEFIT = "defined_benefit"+ HYBRID = "hybrid_plan"+++class ShareBasedType(Enum):+ """Types of share-based compensation"""+ STOCK_OPTIONS = "stock_options"+ RESTRICTED_STOCK = "restricted_stock"+ PERFORMANCE_SHARES = "performance_shares"+ STOCK_APPRECIATION_RIGHTS = "stock_appreciation_rights"+ EMPLOYEE_STOCK_PURCHASE = "employee_stock_purchase_plan"+++class FundingStatus(Enum):+ """Pension plan funding status"""+ OVERFUNDED = "overfunded"+ FULLY_FUNDED = "fully_funded"+ UNDERFUNDED = "underfunded"+ SEVERELY_UNDERFUNDED = "severely_underfunded"+++@dataclass+class PostEmploymentAnalysis:+ """Post-employment benefits analysis"""+ total_pension_obligation: float+ plan_assets_fair_value: float+ funded_status: float+ funding_ratio: float++ # Plan breakdown+ defined_benefit_obligation: float+ defined_contribution_assets: float++ # Annual costs+ service_cost: float+ interest_cost: float+ expected_return_on_assets: float+ net_periodic_cost: float++ # Risk factors+ funding_status_enum: FundingStatus+ actuarial_assumptions_risk: RiskLevel+ demographic_risk: RiskLevel+ investment_risk: RiskLevel+++@dataclass+class ShareBasedCompensationAnalysis:+ """Share-based compensation analysis"""+ total_sbc_expense: float+ sbc_intensity: float # SBC / Revenue++ # Composition+ stock_option_expense: float+ restricted_stock_expense: float+ performance_share_expense: float++ # Dilution metrics+ potential_dilution: float+ weighted_average_dilutive_shares: float++ # Valuation metrics+ fair_value_assumptions: Dict[str, float] = field(default_factory=dict)+ expense_timing_pattern: str = ""++ # Strategic implications+ retention_effectiveness: str = ""+ performance_alignment: RiskLevel = RiskLevel.MODERATE+++@dataclass+class CompensationStrategy:+ """Overall compensation strategy analysis"""+ total_compensation_expense: float+ compensation_intensity: float # Total comp / Revenue++ # Mix analysis+ cash_compensation_ratio: float+ equity_compensation_ratio: float+ benefits_ratio: float++ # Benchmarking+ industry_competitiveness: str = ""+ retention_risk: RiskLevel = RiskLevel.MODERATE+ cost_efficiency: float = 0.0+++class EmployeeCompensationAnalyzer(BaseAnalyzer):+ """+ Comprehensive employee compensation analyzer implementing CFA Level II standards.+ Covers post-employment benefits and share-based compensation.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_compensation_formulas()+ self._initialize_compensation_benchmarks()++ def _initialize_compensation_formulas(self):+ """Initialize compensation-specific formulas"""+ self.formula_registry.update({+ 'funding_ratio': lambda plan_assets, pension_obligation: self.safe_divide(plan_assets, pension_obligation),+ 'sbc_intensity': lambda sbc_expense, revenue: self.safe_divide(sbc_expense, revenue),+ 'compensation_intensity': lambda total_comp, revenue: self.safe_divide(total_comp, revenue),+ 'dilution_impact': lambda dilutive_shares, basic_shares: self.safe_divide(dilutive_shares, basic_shares),+ 'pension_cost_ratio': lambda pension_cost, operating_income: self.safe_divide(pension_cost,+ operating_income),+ 'benefit_coverage': lambda plan_assets, current_liabilities: self.safe_divide(plan_assets,+ current_liabilities)+ })++ def _initialize_compensation_benchmarks(self):+ """Initialize compensation-specific benchmarks"""+ self.compensation_benchmarks = {+ 'funding_ratio': {'overfunded': 1.1, 'fully_funded': 1.0, 'underfunded': 0.9, 'severely_underfunded': 0.8},+ 'sbc_intensity': {'low': 0.02, 'moderate': 0.05, 'high': 0.10, 'very_high': 0.20},+ 'compensation_intensity': {'low': 0.3, 'moderate': 0.4, 'high': 0.6, 'very_high': 0.8},+ 'dilution_impact': {'minimal': 0.02, 'moderate': 0.05, 'significant': 0.10, 'excessive': 0.20}+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive employee compensation analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all compensation aspects+ """+ results = []++ # Post-employment benefits analysis+ results.extend(self._analyze_post_employment_benefits(statements, comparative_data, industry_data))++ # Share-based compensation analysis+ results.extend(self._analyze_share_based_compensation(statements, comparative_data, industry_data))++ # Overall compensation strategy+ results.extend(self._analyze_compensation_strategy(statements, comparative_data, industry_data))++ # Pension risk assessment+ results.extend(self._assess_pension_risks(statements, comparative_data))++ # SBC forecasting implications+ results.extend(self._analyze_sbc_forecasting(statements, comparative_data))++ # Valuation considerations+ results.extend(self._assess_valuation_impact(statements, comparative_data))++ return results++ def _analyze_post_employment_benefits(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze post-employment benefit plans"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ # Extract pension-related data+ pension_obligation = balance_sheet.get('pension_obligation', 0)+ pension_assets = balance_sheet.get('pension_plan_assets', 0)+ pension_liability = balance_sheet.get('pension_liability', 0)++ pension_expense = income_statement.get('pension_expense', 0)+ service_cost = notes.get('pension_service_cost', 0)+ interest_cost = notes.get('pension_interest_cost', 0)+ expected_return = notes.get('expected_return_plan_assets', 0)++ if pension_obligation <= 0 and pension_expense <= 0:+ return results++ # Funding Status Analysis+ if pension_obligation > 0:+ funded_status = pension_assets - pension_obligation+ funding_ratio = self.safe_divide(pension_assets, pension_obligation)++ # Determine funding status category+ if funding_ratio >= 1.1:+ funding_status = FundingStatus.OVERFUNDED+ funding_interpretation = "Pension plan is overfunded - surplus available"+ funding_risk = RiskLevel.LOW+ elif funding_ratio >= 1.0:+ funding_status = FundingStatus.FULLY_FUNDED+ funding_interpretation = "Pension plan is fully funded"+ funding_risk = RiskLevel.LOW+ elif funding_ratio >= 0.8:+ funding_status = FundingStatus.UNDERFUNDED+ funding_interpretation = "Pension plan is underfunded - future contributions required"+ funding_risk = RiskLevel.MODERATE+ else:+ funding_status = FundingStatus.SEVERELY_UNDERFUNDED+ funding_interpretation = "Pension plan is severely underfunded - significant funding risk"+ funding_risk = RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Pension Funding Ratio",+ value=funding_ratio,+ interpretation=funding_interpretation,+ risk_level=funding_risk,+ benchmark_comparison=self.compare_to_industry(funding_ratio, industry_data.get(+ 'pension_funding_ratio') if industry_data else None),+ methodology="Plan Assets / Pension Benefit Obligation",+ limitations=["Funding ratio based on actuarial assumptions that may change"]+ ))++ # Funded Status Impact on Balance Sheet+ total_assets = balance_sheet.get('total_assets', 0)+ if total_assets > 0:+ funded_status_ratio = self.safe_divide(abs(funded_status), total_assets)++ if funded_status < 0: # Underfunded+ status_interpretation = f"Pension underfunding represents {self.format_percentage(funded_status_ratio)} of total assets"+ status_risk = RiskLevel.HIGH if funded_status_ratio > 0.1 else RiskLevel.MODERATE if funded_status_ratio > 0.05 else RiskLevel.LOW+ else: # Overfunded+ status_interpretation = f"Pension overfunding represents {self.format_percentage(funded_status_ratio)} of total assets"+ status_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Pension Funded Status Impact",+ value=funded_status_ratio,+ interpretation=status_interpretation,+ risk_level=status_risk,+ methodology="|Funded Status| / Total Assets"+ ))++ # Pension Cost Analysis+ if pension_expense > 0:+ revenue = income_statement.get('revenue', 0)+ if revenue > 0:+ pension_cost_intensity = self.safe_divide(pension_expense, revenue)++ cost_interpretation = "High pension cost burden" if pension_cost_intensity > 0.05 else "Moderate pension costs" if pension_cost_intensity > 0.02 else "Low pension cost impact"+ cost_risk = RiskLevel.MODERATE if pension_cost_intensity > 0.08 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Pension Cost Intensity",+ value=pension_cost_intensity,+ interpretation=cost_interpretation,+ risk_level=cost_risk,+ methodology="Pension Expense / Revenue"+ ))++ # Service Cost vs Interest Cost Analysis+ if service_cost > 0 and interest_cost > 0:+ total_cost_components = service_cost + interest_cost+ service_cost_ratio = self.safe_divide(service_cost, total_cost_components)++ service_interpretation = "Service cost dominates - active workforce driving costs" if service_cost_ratio > 0.6 else "Balanced service and interest costs" if service_cost_ratio > 0.4 else "Interest cost dominates - mature plan with large obligation"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Pension Cost Composition",+ value=service_cost_ratio,+ interpretation=service_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Service Cost / (Service Cost + Interest Cost)"+ ))++ # Expected Return vs Actual Return Analysis+ actual_return = notes.get('actual_return_plan_assets', 0)+ if expected_return > 0 and actual_return != 0:+ return_variance = actual_return - expected_return+ return_variance_ratio = self.safe_divide(abs(return_variance), abs(expected_return))++ variance_interpretation = "Significant variance between expected and actual returns" if return_variance_ratio > 0.2 else "Moderate return variance" if return_variance_ratio > 0.1 else "Returns close to expectations"+ variance_risk = RiskLevel.MODERATE if return_variance_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Pension Return Variance",+ value=return_variance_ratio,+ interpretation=variance_interpretation,+ risk_level=variance_risk,+ methodology="|Actual Return - Expected Return| / |Expected Return|"+ ))++ return results++ def _analyze_share_based_compensation(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze share-based compensation"""+ results = []++ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet+ notes = statements.notes++ sbc_expense = income_statement.get('stock_compensation', 0)+ revenue = income_statement.get('revenue', 0)++ if sbc_expense <= 0:+ return results++ # SBC Intensity Analysis+ if revenue > 0:+ sbc_intensity = self.safe_divide(sbc_expense, revenue)+ benchmark = self.compensation_benchmarks['sbc_intensity']++ if sbc_intensity > benchmark['very_high']:+ intensity_interpretation = "Very high share-based compensation intensity - significant equity dilution concern"+ intensity_risk = RiskLevel.HIGH+ elif sbc_intensity > benchmark['high']:+ intensity_interpretation = "High share-based compensation usage"+ intensity_risk = RiskLevel.MODERATE+ elif sbc_intensity > benchmark['moderate']:+ intensity_interpretation = "Moderate share-based compensation"+ intensity_risk = RiskLevel.LOW+ else:+ intensity_interpretation = "Low share-based compensation usage"+ intensity_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Share-Based Compensation Intensity",+ value=sbc_intensity,+ interpretation=intensity_interpretation,+ risk_level=intensity_risk,+ benchmark_comparison=self.compare_to_industry(sbc_intensity, industry_data.get(+ 'sbc_intensity') if industry_data else None),+ methodology="Stock-Based Compensation Expense / Revenue",+ limitations=["High SBC may indicate cash conservation or growth stage"]+ ))++ # Dilution Impact Analysis+ basic_shares = income_statement.get('shares_outstanding_basic', 0)+ diluted_shares = income_statement.get('shares_outstanding_diluted', 0)++ if basic_shares > 0 and diluted_shares > basic_shares:+ dilutive_shares = diluted_shares - basic_shares+ dilution_impact = self.safe_divide(dilutive_shares, basic_shares)+ benchmark = self.compensation_benchmarks['dilution_impact']++ if dilution_impact > benchmark['excessive']:+ dilution_interpretation = "Excessive dilution from share-based compensation"+ dilution_risk = RiskLevel.HIGH+ elif dilution_impact > benchmark['significant']:+ dilution_interpretation = "Significant dilution impact"+ dilution_risk = RiskLevel.MODERATE+ elif dilution_impact > benchmark['moderate']:+ dilution_interpretation = "Moderate dilution from SBC"+ dilution_risk = RiskLevel.LOW+ else:+ dilution_interpretation = "Minimal dilution impact"+ dilution_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="SBC Dilution Impact",+ value=dilution_impact,+ interpretation=dilution_interpretation,+ risk_level=dilution_risk,+ methodology="(Diluted Shares - Basic Shares) / Basic Shares"+ ))++ # SBC Expense Trend Analysis+ if comparative_data and len(comparative_data) >= 2:+ sbc_values = []+ revenue_values = []++ for past_statements in comparative_data:+ past_sbc = past_statements.income_statement.get('stock_compensation', 0)+ past_revenue = past_statements.income_statement.get('revenue', 0)+ sbc_values.append(past_sbc)+ revenue_values.append(past_revenue)++ sbc_values.append(sbc_expense)+ revenue_values.append(revenue)++ if len(sbc_values) > 2:+ sbc_trend = self.calculate_trend(sbc_values, [f"Period-{i}" for i in range(len(sbc_values))])++ # Compare SBC growth to revenue growth+ if len(revenue_values) == len(sbc_values):+ revenue_trend = self.calculate_trend(revenue_values,+ [f"Period-{i}" for i in range(len(revenue_values))])++ if sbc_trend.growth_rate and revenue_trend.growth_rate:+ relative_growth = sbc_trend.growth_rate - revenue_trend.growth_rate++ if relative_growth > 0.1:+ trend_interpretation = "SBC expense growing faster than revenue - increasing compensation intensity"+ trend_risk = RiskLevel.MODERATE+ elif relative_growth > -0.1:+ trend_interpretation = "SBC expense growth aligned with revenue growth"+ trend_risk = RiskLevel.LOW+ else:+ trend_interpretation = "SBC expense declining relative to revenue - improving efficiency"+ trend_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="SBC Growth vs Revenue Growth",+ value=relative_growth,+ interpretation=trend_interpretation,+ risk_level=trend_risk,+ methodology="SBC Growth Rate - Revenue Growth Rate"+ ))++ # SBC Composition Analysis+ stock_option_expense = notes.get('stock_option_expense', 0)+ restricted_stock_expense = notes.get('restricted_stock_expense', 0)+ performance_share_expense = notes.get('performance_share_expense', 0)++ total_detailed_sbc = stock_option_expense + restricted_stock_expense + performance_share_expense++ if total_detailed_sbc > 0 and abs(total_detailed_sbc - sbc_expense) / sbc_expense < 0.1:+ # Analyze composition if detailed breakdown is available+ sbc_types = {+ 'Stock Options': stock_option_expense,+ 'Restricted Stock': restricted_stock_expense,+ 'Performance Shares': performance_share_expense+ }++ for sbc_type, sbc_value in sbc_types.items():+ if sbc_value > 0:+ sbc_type_ratio = self.safe_divide(sbc_value, total_detailed_sbc)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=f"{sbc_type} Composition",+ value=sbc_type_ratio,+ interpretation=f"{sbc_type} represents {self.format_percentage(sbc_type_ratio)} of total SBC expense",+ risk_level=RiskLevel.LOW,+ methodology=f"{sbc_type} Expense / Total SBC Expense"+ ))++ # Performance-Based Compensation Analysis+ if performance_share_expense > 0:+ performance_ratio = self.safe_divide(performance_share_expense, sbc_expense)++ performance_interpretation = "High performance-based compensation alignment" if performance_ratio > 0.4 else "Moderate performance alignment" if performance_ratio > 0.2 else "Limited performance-based compensation"+ performance_risk = RiskLevel.LOW if performance_ratio > 0.3 else RiskLevel.MODERATE++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Performance-Based SBC Ratio",+ value=performance_ratio,+ interpretation=performance_interpretation,+ risk_level=performance_risk,+ methodology="Performance Share Expense / Total SBC Expense",+ limitations=["Performance alignment depends on specific performance metrics used"]+ ))++ return results++ def _analyze_compensation_strategy(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze overall compensation strategy"""+ results = []++ income_statement = statements.income_statement++ # Total compensation components+ employee_costs = income_statement.get('employee_costs', 0)+ pension_expense = income_statement.get('pension_expense', 0)+ sbc_expense = income_statement.get('stock_compensation', 0)+ other_benefits = income_statement.get('other_employee_benefits', 0)++ total_compensation = employee_costs + pension_expense + sbc_expense + other_benefits+ revenue = income_statement.get('revenue', 0)++ if total_compensation <= 0:+ return results++ # Total Compensation Intensity+ if revenue > 0:+ compensation_intensity = self.safe_divide(total_compensation, revenue)+ benchmark = self.compensation_benchmarks['compensation_intensity']++ if compensation_intensity > benchmark['very_high']:+ intensity_interpretation = "Very high compensation intensity - labor-intensive business model"+ intensity_risk = RiskLevel.MODERATE+ elif compensation_intensity > benchmark['high']:+ intensity_interpretation = "High compensation costs relative to revenue"+ intensity_risk = RiskLevel.MODERATE+ elif compensation_intensity > benchmark['moderate']:+ intensity_interpretation = "Moderate compensation intensity"+ intensity_risk = RiskLevel.LOW+ else:+ intensity_interpretation = "Low compensation intensity - capital-intensive or automated business"+ intensity_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Total Compensation Intensity",+ value=compensation_intensity,+ interpretation=intensity_interpretation,+ risk_level=intensity_risk,+ benchmark_comparison=self.compare_to_industry(compensation_intensity, industry_data.get(+ 'compensation_intensity') if industry_data else None),+ methodology="Total Employee Compensation / Revenue"+ ))++ # Compensation Mix Analysis+ if total_compensation > 0:+ cash_compensation_ratio = self.safe_divide(employee_costs, total_compensation)+ equity_compensation_ratio = self.safe_divide(sbc_expense, total_compensation)+ benefits_ratio = self.safe_divide(pension_expense + other_benefits, total_compensation)++ mix_components = {+ 'Cash Compensation Ratio': cash_compensation_ratio,+ 'Equity Compensation Ratio': equity_compensation_ratio,+ 'Benefits Ratio': benefits_ratio+ }++ for component, ratio in mix_components.items():+ if ratio > 0:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=component,+ value=ratio,+ interpretation=f"{component.replace('_', ' ')} of {self.format_percentage(ratio)}",+ risk_level=RiskLevel.LOW,+ methodology=f"Component / Total Compensation"+ ))++ # Strategic assessment of mix+ if equity_compensation_ratio > 0.2:+ strategy_assessment = "Equity-heavy compensation strategy - retention and performance focus"+ strategy_risk = RiskLevel.MODERATE+ elif benefits_ratio > 0.3:+ strategy_assessment = "Benefits-heavy compensation - traditional employment model"+ strategy_risk = RiskLevel.LOW+ else:+ strategy_assessment = "Cash-focused compensation strategy"+ strategy_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Compensation Strategy Assessment",+ value=1.0,+ interpretation=strategy_assessment,+ risk_level=strategy_risk,+ methodology="Qualitative assessment of compensation mix"+ ))++ return results++ def _assess_pension_risks(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Assess pension-related risks"""+ results = []++ notes = statements.notes++ # Actuarial Assumption Risk+ discount_rate = notes.get('pension_discount_rate', 0)+ expected_return_rate = notes.get('expected_return_rate', 0)+ salary_increase_rate = notes.get('salary_increase_assumption', 0)++ if discount_rate > 0:+ # Assess discount rate appropriateness (simplified)+ if discount_rate < 0.03:+ discount_interpretation = "Very low discount rate increases pension obligation sensitivity"+ discount_risk = RiskLevel.HIGH+ elif discount_rate < 0.05:+ discount_interpretation = "Low discount rate environment - moderate sensitivity"+ discount_risk = RiskLevel.MODERATE+ else:+ discount_interpretation = "Reasonable discount rate assumption"+ discount_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Pension Discount Rate Risk",+ value=discount_rate,+ interpretation=discount_interpretation,+ risk_level=discount_risk,+ methodology="Assessment of discount rate level and sensitivity",+ limitations=["Discount rate changes significantly impact pension obligations"]+ ))++ # Expected Return vs Discount Rate Analysis+ if expected_return_rate > 0 and discount_rate > 0:+ return_premium = expected_return_rate - discount_rate++ if return_premium > 0.02:+ return_interpretation = "High expected return premium - aggressive investment assumption"+ return_risk = RiskLevel.MODERATE+ elif return_premium > 0:+ return_interpretation = "Positive expected return premium"+ return_risk = RiskLevel.LOW+ else:+ return_interpretation = "Conservative expected return assumption"+ return_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Expected Return Premium",+ value=return_premium,+ interpretation=return_interpretation,+ risk_level=return_risk,+ methodology="Expected Return Rate - Discount Rate"+ ))++ # Demographic Risk Assessment+ average_participant_age = notes.get('average_participant_age', 0)+ if average_participant_age > 0:+ if average_participant_age > 55:+ demographic_interpretation = "Aging participant base - increasing near-term benefit payments"+ demographic_risk = RiskLevel.MODERATE+ elif average_participant_age > 45:+ demographic_interpretation = "Mature participant base"+ demographic_risk = RiskLevel.LOW+ else:+ demographic_interpretation = "Young participant base - deferred benefit payments"+ demographic_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Pension Demographic Risk",+ value=average_participant_age,+ interpretation=demographic_interpretation,+ risk_level=demographic_risk,+ methodology="Assessment of participant age profile"+ ))++ return results++ def _analyze_sbc_forecasting(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze SBC forecasting implications"""+ results = []++ notes = statements.notes+ income_statement = statements.income_statement++ # Unvested SBC Analysis+ unvested_sbc_value = notes.get('unvested_sbc_value', 0)+ weighted_average_vesting_period = notes.get('weighted_average_vesting_period', 0)++ if unvested_sbc_value > 0:+ # Future expense estimation+ current_sbc_expense = income_statement.get('stock_compensation', 0)++ if weighted_average_vesting_period > 0:+ estimated_annual_expense = self.safe_divide(unvested_sbc_value, weighted_average_vesting_period)++ if current_sbc_expense > 0:+ future_expense_ratio = self.safe_divide(estimated_annual_expense, current_sbc_expense)++ if future_expense_ratio > 1.2:+ forecasting_interpretation = "SBC expense expected to increase significantly based on unvested awards"+ forecasting_risk = RiskLevel.MODERATE+ elif future_expense_ratio > 0.8:+ forecasting_interpretation = "SBC expense expected to remain stable"+ forecasting_risk = RiskLevel.LOW+ else:+ forecasting_interpretation = "SBC expense expected to decline"+ forecasting_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="SBC Future Expense Indicator",+ value=future_expense_ratio,+ interpretation=forecasting_interpretation,+ risk_level=forecasting_risk,+ methodology="Estimated Future Annual SBC Expense / Current SBC Expense"+ ))++ # Share Count Projections+ options_outstanding = notes.get('stock_options_outstanding', 0)+ weighted_average_exercise_price = notes.get('weighted_average_exercise_price', 0)+ current_stock_price = notes.get('current_stock_price', 0)++ if options_outstanding > 0 and current_stock_price > 0 and weighted_average_exercise_price > 0:+ # Estimate potential dilution from in-the-money options+ if current_stock_price > weighted_average_exercise_price:+ intrinsic_value_ratio = (current_stock_price - weighted_average_exercise_price) / current_stock_price++ if intrinsic_value_ratio > 0.3:+ dilution_interpretation = "Significant in-the-money options - high exercise probability"+ dilution_risk = RiskLevel.MODERATE+ elif intrinsic_value_ratio > 0.1:+ dilution_interpretation = "Moderate in-the-money options"+ dilution_risk = RiskLevel.LOW+ else:+ dilution_interpretation = "Limited intrinsic value in outstanding options"+ dilution_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Option Intrinsic Value Ratio",+ value=intrinsic_value_ratio,+ interpretation=dilution_interpretation,+ risk_level=dilution_risk,+ methodology="(Current Price - Exercise Price) / Current Price"+ ))++ return results++ def _assess_valuation_impact(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Assess valuation implications of compensation arrangements"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ # Pension Obligation Impact on Enterprise Value+ pension_obligation = balance_sheet.get('pension_obligation', 0)+ pension_assets = balance_sheet.get('pension_plan_assets', 0)+ net_pension_liability = pension_obligation - pension_assets++ if net_pension_liability > 0:+ total_debt = balance_sheet.get('long_term_debt', 0) + balance_sheet.get('short_term_debt', 0)++ if total_debt > 0:+ pension_debt_ratio = self.safe_divide(net_pension_liability, total_debt)++ valuation_interpretation = "Pension liability significantly impacts debt-like obligations" if pension_debt_ratio > 0.5 else "Moderate pension liability impact" if pension_debt_ratio > 0.2 else "Limited pension liability impact on valuation"+ valuation_risk = RiskLevel.MODERATE if pension_debt_ratio > 0.4 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.VALUATION,+ metric_name="Pension Liability to Debt Ratio",+ value=pension_debt_ratio,+ interpretation=valuation_interpretation,+ risk_level=valuation_risk,+ methodology="Net Pension Liability / Total Debt",+ limitations=["Pension obligations should be considered in enterprise valuation"]+ ))++ # SBC Cash Flow Impact+ sbc_expense = income_statement.get('stock_compensation', 0)+ tax_rate = 0.25 # Simplified assumption++ if sbc_expense > 0:+ # SBC provides tax deduction but no cash cost+ sbc_tax_benefit = sbc_expense * tax_rate++ cash_flow_benefit_ratio = self.safe_divide(sbc_tax_benefit, sbc_expense)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.VALUATION,+ metric_name="SBC Tax Benefit Ratio",+ value=cash_flow_benefit_ratio,+ interpretation=f"SBC provides tax benefits worth {self.format_percentage(cash_flow_benefit_ratio)} of expense",+ risk_level=RiskLevel.LOW,+ methodology="(SBC Expense × Tax Rate) / SBC Expense",+ limitations=["Actual tax benefits depend on company's tax position"]+ ))++ return results++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key employee compensation metrics"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ metrics = {}++ # Pension metrics+ pension_obligation = balance_sheet.get('pension_obligation', 0)+ pension_assets = balance_sheet.get('pension_plan_assets', 0)++ if pension_obligation > 0:+ metrics['pension_funding_ratio'] = self.safe_divide(pension_assets, pension_obligation)+ metrics['pension_funded_status'] = pension_assets - pension_obligation++ pension_expense = income_statement.get('pension_expense', 0)+ revenue = income_statement.get('revenue', 0)++ if revenue > 0 and pension_expense > 0:+ metrics['pension_cost_intensity'] = self.safe_divide(pension_expense, revenue)++ # SBC metrics+ sbc_expense = income_statement.get('stock_compensation', 0)+ if revenue > 0 and sbc_expense > 0:+ metrics['sbc_intensity'] = self.safe_divide(sbc_expense, revenue)++ # Dilution metrics+ basic_shares = income_statement.get('shares_outstanding_basic', 0)+ diluted_shares = income_statement.get('shares_outstanding_diluted', 0)++ if basic_shares > 0 and diluted_shares > basic_shares:+ metrics['dilution_impact'] = self.safe_divide(diluted_shares - basic_shares, basic_shares)++ # Total compensation intensity+ employee_costs = income_statement.get('employee_costs', 0)+ total_compensation = employee_costs + pension_expense + sbc_expense++ if revenue > 0 and total_compensation > 0:+ metrics['total_compensation_intensity'] = self.safe_divide(total_compensation, revenue)++ return metrics++ def create_post_employment_analysis(self, statements: FinancialStatements) -> PostEmploymentAnalysis:+ """Create comprehensive post-employment benefits analysis object"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ # Extract pension data+ total_pension_obligation = balance_sheet.get('pension_obligation', 0)+ plan_assets_fair_value = balance_sheet.get('pension_plan_assets', 0)+ funded_status = plan_assets_fair_value - total_pension_obligation+ funding_ratio = self.safe_divide(plan_assets_fair_value,+ total_pension_obligation) if total_pension_obligation > 0 else 0++ # Plan breakdown+ defined_benefit_obligation = balance_sheet.get('defined_benefit_obligation', total_pension_obligation)+ defined_contribution_assets = balance_sheet.get('defined_contribution_assets', 0)++ # Annual costs+ service_cost = notes.get('pension_service_cost', 0)+ interest_cost = notes.get('pension_interest_cost', 0)+ expected_return_on_assets = notes.get('expected_return_plan_assets', 0)+ net_periodic_cost = income_statement.get('pension_expense', 0)++ # Determine funding status category+ if funding_ratio >= 1.1:+ funding_status_enum = FundingStatus.OVERFUNDED+ elif funding_ratio >= 1.0:+ funding_status_enum = FundingStatus.FULLY_FUNDED+ elif funding_ratio >= 0.8:+ funding_status_enum = FundingStatus.UNDERFUNDED+ else:+ funding_status_enum = FundingStatus.SEVERELY_UNDERFUNDED++ # Risk assessments+ discount_rate = notes.get('pension_discount_rate', 0)+ if discount_rate < 0.04:+ actuarial_assumptions_risk = RiskLevel.HIGH+ elif discount_rate < 0.06:+ actuarial_assumptions_risk = RiskLevel.MODERATE+ else:+ actuarial_assumptions_risk = RiskLevel.LOW++ average_age = notes.get('average_participant_age', 50)+ demographic_risk = RiskLevel.MODERATE if average_age > 55 else RiskLevel.LOW++ # Investment risk based on asset allocation+ equity_allocation = notes.get('pension_equity_allocation', 0.6) # Default 60%+ investment_risk = RiskLevel.HIGH if equity_allocation > 0.8 else RiskLevel.MODERATE if equity_allocation > 0.5 else RiskLevel.LOW++ return PostEmploymentAnalysis(+ total_pension_obligation=total_pension_obligation,+ plan_assets_fair_value=plan_assets_fair_value,+ funded_status=funded_status,+ funding_ratio=funding_ratio,+ defined_benefit_obligation=defined_benefit_obligation,+ defined_contribution_assets=defined_contribution_assets,+ service_cost=service_cost,+ interest_cost=interest_cost,+ expected_return_on_assets=expected_return_on_assets,+ net_periodic_cost=net_periodic_cost,+ funding_status_enum=funding_status_enum,+ actuarial_assumptions_risk=actuarial_assumptions_risk,+ demographic_risk=demographic_risk,+ investment_risk=investment_risk+ )++ def create_sbc_analysis(self, statements: FinancialStatements) -> ShareBasedCompensationAnalysis:+ """Create comprehensive share-based compensation analysis object"""++ income_statement = statements.income_statement+ notes = statements.notes++ total_sbc_expense = income_statement.get('stock_compensation', 0)+ revenue = income_statement.get('revenue', 0)+ sbc_intensity = self.safe_divide(total_sbc_expense, revenue) if revenue > 0 else 0++ # Composition+ stock_option_expense = notes.get('stock_option_expense', 0)+ restricted_stock_expense = notes.get('restricted_stock_expense', 0)+ performance_share_expense = notes.get('performance_share_expense', 0)++ # Dilution metrics+ basic_shares = income_statement.get('shares_outstanding_basic', 0)+ diluted_shares = income_statement.get('shares_outstanding_diluted', 0)+ potential_dilution = self.safe_divide(diluted_shares - basic_shares, basic_shares) if basic_shares > 0 else 0+ weighted_average_dilutive_shares = diluted_shares - basic_shares++ # Fair value assumptions+ fair_value_assumptions = {+ 'volatility': notes.get('sbc_volatility_assumption', 0),+ 'risk_free_rate': notes.get('sbc_risk_free_rate', 0),+ 'expected_life': notes.get('sbc_expected_life', 0),+ 'dividend_yield': notes.get('sbc_dividend_yield', 0)+ }++ # Expense timing+ unvested_value = notes.get('unvested_sbc_value', 0)+ vesting_period = notes.get('weighted_average_vesting_period', 0)++ if unvested_value > 0 and vesting_period > 0:+ expense_timing_pattern = f"${unvested_value:,.0f} to be expensed over {vesting_period:.1f} years"+ else:+ expense_timing_pattern = "Timing information not available"++ # Strategic assessment+ performance_ratio = self.safe_divide(performance_share_expense,+ total_sbc_expense) if total_sbc_expense > 0 else 0++ if performance_ratio > 0.4:+ retention_effectiveness = "High performance alignment"+ performance_alignment = RiskLevel.LOW+ elif performance_ratio > 0.2:+ retention_effectiveness = "Moderate performance alignment"+ performance_alignment = RiskLevel.MODERATE+ else:+ retention_effectiveness = "Limited performance alignment"+ performance_alignment = RiskLevel.MODERATE++ return ShareBasedCompensationAnalysis(+ total_sbc_expense=total_sbc_expense,+ sbc_intensity=sbc_intensity,+ stock_option_expense=stock_option_expense,+ restricted_stock_expense=restricted_stock_expense,+ performance_share_expense=performance_share_expense,+ potential_dilution=potential_dilution,+ weighted_average_dilutive_shares=weighted_average_dilutive_shares,+ fair_value_assumptions=fair_value_assumptions,+ expense_timing_pattern=expense_timing_pattern,+ retention_effectiveness=retention_effectiveness,+ performance_alignment=performance_alignment+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/financial_institutions.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/financial_institutions.pynew file mode 100644index 000000000..6b38bc4b9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/financial_institutions.py@@ -0,0 +1,31 @@++"""+Financial Statement Financial Institutions Module+========================================++Financial institution specialized analysis and risk assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/intercorporate_investments.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/intercorporate_investments.pynew file mode 100644index 000000000..06df0e21c--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/intercorporate_investments.py@@ -0,0 +1,947 @@++"""+Financial Statement Intercorporate Investments Module+========================================++Intercorporate investment analysis and accounting treatment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class InvestmentClassification(Enum):+ """Investment classification under IFRS/GAAP"""+ FVTPL = "fair_value_through_profit_loss" # Fair Value Through P&L+ FVOCI = "fair_value_through_oci" # Fair Value Through OCI+ AMORTIZED_COST = "amortized_cost"+ EQUITY_METHOD = "equity_method"+ CONSOLIDATION = "consolidation"+++class ControlLevel(Enum):+ """Level of control/influence"""+ NO_INFLUENCE = "no_influence" # < 20%+ SIGNIFICANT_INFLUENCE = "significant_influence" # 20-50%+ CONTROL = "control" # > 50%+ JOINT_CONTROL = "joint_control"+++class BusinessCombinationType(Enum):+ """Types of business combinations"""+ ACQUISITION = "acquisition"+ MERGER = "merger"+ ASSET_PURCHASE = "asset_purchase"+ REVERSE_ACQUISITION = "reverse_acquisition"+++@dataclass+class FinancialAssetAnalysis:+ """Analysis of financial asset investments"""+ total_financial_assets: float+ classification_breakdown: Dict[str, float] = field(default_factory=dict)++ # Valuation metrics+ fair_value_assets: float = 0.0+ amortized_cost_assets: float = 0.0+ unrealized_gains_losses: float = 0.0++ # Risk assessment+ credit_risk_exposure: float = 0.0+ market_risk_exposure: float = 0.0+ liquidity_risk: RiskLevel = RiskLevel.LOW++ # Performance metrics+ investment_returns: float = 0.0+ dividend_income: float = 0.0+++@dataclass+class AssociateAnalysis:+ """Analysis of investments in associates"""+ total_associate_investments: float+ number_of_associates: int++ # Equity method metrics+ share_of_profits_losses: float+ dividend_income_associates: float+ carrying_value_change: float++ # Performance assessment+ associate_roe: float = 0.0+ associate_performance_trend: TrendDirection = TrendDirection.STABLE+ impairment_indicators: List[str] = field(default_factory=list)+++@dataclass+class JointVentureAnalysis:+ """Analysis of joint venture investments"""+ total_jv_investments: float+ number_of_joint_ventures: int++ # Joint control assessment+ control_structure: str = ""+ governance_quality: float = 0.0++ # Financial performance+ jv_contribution_to_earnings: float = 0.0+ jv_strategic_value: str = ""+ exit_strategy_clarity: RiskLevel = RiskLevel.MODERATE+++@dataclass+class BusinessCombinationAnalysis:+ """Analysis of business combinations"""+ acquisition_date: str+ purchase_price: float+ fair_value_acquired_assets: float+ assumed_liabilities: float++ # Goodwill analysis+ goodwill_recognized: float+ bargain_purchase_gain: float = 0.0++ # Integration assessment+ synergies_realized: float = 0.0+ integration_costs: float = 0.0+ performance_vs_expectations: str = ""+++class IntercorporateInvestmentsAnalyzer(BaseAnalyzer):+ """+ Comprehensive intercorporate investments analyzer implementing CFA Level II standards.+ Covers all types of intercorporate investments and their accounting treatments.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_investment_formulas()+ self._initialize_investment_benchmarks()++ def _initialize_investment_formulas(self):+ """Initialize investment-specific formulas"""+ self.formula_registry.update({+ 'investment_return': lambda gains_income, beginning_value: self.safe_divide(gains_income, beginning_value),+ 'dividend_yield': lambda dividend_income, investment_value: self.safe_divide(dividend_income,+ investment_value),+ 'investment_intensity': lambda total_investments, total_assets: self.safe_divide(total_investments,+ total_assets),+ 'equity_method_return': lambda share_of_earnings, carrying_value: self.safe_divide(share_of_earnings,+ carrying_value),+ 'goodwill_premium': lambda goodwill, purchase_price: self.safe_divide(goodwill, purchase_price),+ 'acquisition_multiple': lambda purchase_price, acquired_earnings: self.safe_divide(purchase_price,+ acquired_earnings)+ })++ def _initialize_investment_benchmarks(self):+ """Initialize investment-specific benchmarks"""+ self.investment_benchmarks = {+ 'investment_intensity': {'low': 0.1, 'moderate': 0.2, 'high': 0.4, 'very_high': 0.6},+ 'investment_return': {'excellent': 0.15, 'good': 0.10, 'adequate': 0.05, 'poor': 0.0},+ 'goodwill_premium': {'reasonable': 0.3, 'high': 0.5, 'excessive': 0.7},+ 'acquisition_multiple': {'reasonable': 15, 'high': 25, 'excessive': 40}+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive intercorporate investments analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all investment aspects+ """+ results = []++ # Financial assets analysis+ results.extend(self._analyze_financial_assets(statements, comparative_data, industry_data))++ # Associates analysis+ results.extend(self._analyze_associates(statements, comparative_data))++ # Joint ventures analysis+ results.extend(self._analyze_joint_ventures(statements, comparative_data))++ # Business combinations analysis+ results.extend(self._analyze_business_combinations(statements, comparative_data))++ # Special purpose entities analysis+ results.extend(self._analyze_spe_vie(statements, comparative_data))++ # IFRS vs US GAAP differences+ results.extend(self._analyze_gaap_differences(statements))++ # Overall investment strategy assessment+ results.extend(self._assess_investment_strategy(statements, comparative_data))++ return results++ def _analyze_financial_assets(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze financial asset investments"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ # Extract financial asset categories+ financial_assets = {+ 'trading_securities': balance_sheet.get('trading_securities', 0),+ 'afs_securities': balance_sheet.get('available_for_sale_securities', 0),+ 'htm_securities': balance_sheet.get('held_to_maturity_securities', 0),+ 'fvtpl_assets': balance_sheet.get('fvtpl_financial_assets', 0),+ 'fvoci_assets': balance_sheet.get('fvoci_financial_assets', 0),+ 'amortized_cost_assets': balance_sheet.get('amortized_cost_financial_assets', 0)+ }++ total_financial_assets = sum(financial_assets.values())+ total_assets = balance_sheet.get('total_assets', 0)++ if total_financial_assets <= 0:+ return results++ # Investment Intensity Analysis+ if total_assets > 0:+ investment_intensity = self.safe_divide(total_financial_assets, total_assets)+ benchmark = self.investment_benchmarks['investment_intensity']++ if investment_intensity > benchmark['very_high']:+ intensity_interpretation = "Very high financial asset intensity - investment-focused business model"+ intensity_risk = RiskLevel.MODERATE+ elif investment_intensity > benchmark['high']:+ intensity_interpretation = "High financial asset concentration"+ intensity_risk = RiskLevel.MODERATE+ elif investment_intensity > benchmark['moderate']:+ intensity_interpretation = "Moderate financial asset investments"+ intensity_risk = RiskLevel.LOW+ else:+ intensity_interpretation = "Low financial asset concentration"+ intensity_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Financial Asset Intensity",+ value=investment_intensity,+ interpretation=intensity_interpretation,+ risk_level=intensity_risk,+ benchmark_comparison=self.compare_to_industry(investment_intensity, industry_data.get(+ 'investment_intensity') if industry_data else None),+ methodology="Total Financial Assets / Total Assets"+ ))++ # Classification Analysis+ if total_financial_assets > 0:+ for asset_type, value in financial_assets.items():+ if value > 0:+ asset_ratio = self.safe_divide(value, total_financial_assets)+ asset_name = asset_type.replace('_', ' ').title()++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=f"{asset_name} Composition",+ value=asset_ratio,+ interpretation=f"{asset_name} represents {self.format_percentage(asset_ratio)} of total financial assets",+ risk_level=RiskLevel.LOW,+ methodology=f"{asset_name} / Total Financial Assets"+ ))++ # Fair Value vs Amortized Cost Analysis+ fair_value_assets = financial_assets['trading_securities'] + financial_assets['afs_securities'] + \+ financial_assets['fvtpl_assets'] + financial_assets['fvoci_assets']+ amortized_cost_assets = financial_assets['htm_securities'] + financial_assets['amortized_cost_assets']++ if total_financial_assets > 0:+ fair_value_ratio = self.safe_divide(fair_value_assets, total_financial_assets)++ fv_interpretation = "High fair value measurement exposure - significant market risk" if fair_value_ratio > 0.7 else "Moderate fair value exposure" if fair_value_ratio > 0.4 else "Low fair value measurement exposure"+ fv_risk = RiskLevel.HIGH if fair_value_ratio > 0.8 else RiskLevel.MODERATE if fair_value_ratio > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Fair Value Asset Ratio",+ value=fair_value_ratio,+ interpretation=fv_interpretation,+ risk_level=fv_risk,+ methodology="Fair Value Assets / Total Financial Assets",+ limitations=["Fair value assets subject to market volatility"]+ ))++ # Investment Performance Analysis+ investment_income = income_statement.get('investment_income', 0)+ realized_gains = income_statement.get('realized_investment_gains', 0)+ unrealized_gains = income_statement.get('unrealized_investment_gains', 0)++ total_investment_return = investment_income + realized_gains + unrealized_gains++ if total_financial_assets > 0 and total_investment_return != 0:+ investment_return = self.safe_divide(total_investment_return, total_financial_assets)+ benchmark = self.investment_benchmarks['investment_return']++ return_risk = self.assess_risk_level(investment_return, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Financial Asset Return",+ value=investment_return,+ interpretation=self.generate_interpretation("financial asset return", investment_return, return_risk,+ AnalysisType.PROFITABILITY),+ risk_level=return_risk,+ methodology="(Investment Income + Realized Gains + Unrealized Gains) / Total Financial Assets"+ ))++ return results++ def _analyze_associates(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze investments in associates using equity method"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ associate_investments = balance_sheet.get('investments_in_associates', 0)+ share_of_associate_profits = income_statement.get('share_of_associate_profits', 0)+ associate_dividends = income_statement.get('dividends_from_associates', 0)++ if associate_investments <= 0:+ return results++ # Associate Investment Analysis+ total_assets = balance_sheet.get('total_assets', 0)+ if total_assets > 0:+ associate_intensity = self.safe_divide(associate_investments, total_assets)++ associate_interpretation = "Significant associate investments - substantial equity method exposure" if associate_intensity > 0.2 else "Moderate associate investments" if associate_intensity > 0.1 else "Limited associate investments"+ associate_risk = RiskLevel.MODERATE if associate_intensity > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Associate Investment Intensity",+ value=associate_intensity,+ interpretation=associate_interpretation,+ risk_level=associate_risk,+ methodology="Investments in Associates / Total Assets"+ ))++ # Equity Method Return Analysis+ if associate_investments > 0:+ equity_method_return = self.safe_divide(share_of_associate_profits, associate_investments)++ if equity_method_return > 0.15:+ return_interpretation = "Strong associate performance contributing to earnings"+ return_risk = RiskLevel.LOW+ elif equity_method_return > 0.05:+ return_interpretation = "Adequate associate performance"+ return_risk = RiskLevel.LOW+ elif equity_method_return > 0:+ return_interpretation = "Weak associate performance"+ return_risk = RiskLevel.MODERATE+ else:+ return_interpretation = "Associates generating losses - potential impairment concern"+ return_risk = RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Equity Method Return",+ value=equity_method_return,+ interpretation=return_interpretation,+ risk_level=return_risk,+ methodology="Share of Associate Profits / Investment in Associates"+ ))++ # Dividend Payout from Associates+ if share_of_associate_profits > 0 and associate_dividends > 0:+ associate_payout_ratio = self.safe_divide(associate_dividends, share_of_associate_profits)++ payout_interpretation = "High dividend payout from associates - good cash generation" if associate_payout_ratio > 0.6 else "Moderate dividend payout" if associate_payout_ratio > 0.3 else "Low dividend payout - associates retaining earnings for growth"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Associate Dividend Payout Ratio",+ value=associate_payout_ratio,+ interpretation=payout_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Dividends from Associates / Share of Associate Profits"+ ))++ # Associate Investment Trend Analysis+ if comparative_data and len(comparative_data) > 0:+ prev_associate_investments = comparative_data[-1].balance_sheet.get('investments_in_associates', 0)++ if prev_associate_investments > 0:+ associate_growth = (associate_investments / prev_associate_investments) - 1++ growth_interpretation = "Significant expansion in associate investments" if associate_growth > 0.2 else "Moderate growth in associate investments" if associate_growth > 0.05 else "Stable associate investment base" if associate_growth > -0.05 else "Declining associate investments"+ growth_risk = RiskLevel.MODERATE if associate_growth > 0.5 or associate_growth < -0.2 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Associate Investment Growth",+ value=associate_growth,+ interpretation=growth_interpretation,+ risk_level=growth_risk,+ methodology="(Current Associate Investments - Prior Associate Investments) / Prior Associate Investments"+ ))++ return results++ def _analyze_joint_ventures(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze joint venture investments"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ joint_venture_investments = balance_sheet.get('investments_in_joint_ventures', 0)+ share_of_jv_profits = income_statement.get('share_of_jv_profits', 0)++ if joint_venture_investments <= 0:+ return results++ # Joint Venture Investment Analysis+ total_assets = balance_sheet.get('total_assets', 0)+ if total_assets > 0:+ jv_intensity = self.safe_divide(joint_venture_investments, total_assets)++ jv_interpretation = "Significant joint venture exposure" if jv_intensity > 0.15 else "Moderate joint venture investments" if jv_intensity > 0.05 else "Limited joint venture exposure"+ jv_risk = RiskLevel.MODERATE if jv_intensity > 0.25 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Joint Venture Investment Intensity",+ value=jv_intensity,+ interpretation=jv_interpretation,+ risk_level=jv_risk,+ methodology="Investments in Joint Ventures / Total Assets",+ limitations=["Joint ventures involve shared control and coordination challenges"]+ ))++ # Joint Venture Performance+ if joint_venture_investments > 0:+ jv_return = self.safe_divide(share_of_jv_profits, joint_venture_investments)++ jv_performance_interpretation = "Strong joint venture performance" if jv_return > 0.12 else "Adequate joint venture performance" if jv_return > 0.06 else "Weak joint venture performance" if jv_return > 0 else "Joint ventures generating losses"+ jv_performance_risk = RiskLevel.LOW if jv_return > 0.08 else RiskLevel.MODERATE if jv_return > 0 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Joint Venture Return",+ value=jv_return,+ interpretation=jv_performance_interpretation,+ risk_level=jv_performance_risk,+ methodology="Share of JV Profits / Investment in Joint Ventures"+ ))++ # Joint Venture Strategy Assessment+ jv_count = notes.get('number_of_joint_ventures', 0)+ if jv_count > 0:+ avg_jv_size = self.safe_divide(joint_venture_investments, jv_count)++ strategy_interpretation = f"Portfolio of {jv_count} joint ventures with average investment of ${avg_jv_size:,.0f}"+ strategy_risk = RiskLevel.MODERATE if jv_count > 10 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Joint Venture Portfolio",+ value=avg_jv_size,+ interpretation=strategy_interpretation,+ risk_level=strategy_risk,+ methodology="Total JV Investments / Number of Joint Ventures"+ ))++ return results++ def _analyze_business_combinations(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze business combinations and acquisitions"""+ results = []++ balance_sheet = statements.balance_sheet+ cash_flow = statements.cash_flow+ notes = statements.notes++ acquisitions = cash_flow.get('acquisitions', 0)+ goodwill = balance_sheet.get('goodwill', 0)++ # Acquisition Activity Analysis+ if acquisitions > 0:+ total_assets = balance_sheet.get('total_assets', 0)++ if total_assets > 0:+ acquisition_intensity = self.safe_divide(acquisitions, total_assets)++ acquisition_interpretation = "Significant acquisition activity" if acquisition_intensity > 0.1 else "Moderate acquisition activity" if acquisition_intensity > 0.05 else "Limited acquisition activity"+ acquisition_risk = RiskLevel.MODERATE if acquisition_intensity > 0.2 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Acquisition Activity Intensity",+ value=acquisition_intensity,+ interpretation=acquisition_interpretation,+ risk_level=acquisition_risk,+ methodology="Cash Paid for Acquisitions / Total Assets"+ ))++ # Goodwill Analysis from Acquisitions+ if goodwill > 0 and acquisitions > 0:+ # Estimate goodwill premium (simplified - assumes current year goodwill from acquisitions)+ goodwill_premium = self.safe_divide(goodwill,+ acquisitions) if acquisitions > goodwill else self.safe_divide(goodwill,+ goodwill + acquisitions)+ benchmark = self.investment_benchmarks['goodwill_premium']++ if goodwill_premium > benchmark['excessive']:+ premium_interpretation = "Very high goodwill premium - potential overpayment concern"+ premium_risk = RiskLevel.HIGH+ elif goodwill_premium > benchmark['high']:+ premium_interpretation = "High goodwill premium - monitor integration success"+ premium_risk = RiskLevel.MODERATE+ elif goodwill_premium > benchmark['reasonable']:+ premium_interpretation = "Reasonable goodwill premium"+ premium_risk = RiskLevel.LOW+ else:+ premium_interpretation = "Low goodwill premium - strategic acquisition"+ premium_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Acquisition Goodwill Premium",+ value=goodwill_premium,+ interpretation=premium_interpretation,+ risk_level=premium_risk,+ methodology="Goodwill / Acquisition Price (simplified)",+ limitations=["Simplified calculation - detailed purchase price allocation needed for precision"]+ ))++ # Acquisition Integration Assessment+ if comparative_data and len(comparative_data) >= 2:+ # Look for patterns in acquisition activity+ acquisition_history = []+ for past_statements in comparative_data:+ past_acquisitions = past_statements.cash_flow.get('acquisitions', 0)+ acquisition_history.append(past_acquisitions)++ acquisition_history.append(acquisitions)++ total_acquisitions = sum(acquisition_history)+ if total_acquisitions > 0:+ acquisition_frequency = sum(1 for x in acquisition_history if x > 0) / len(acquisition_history)++ frequency_interpretation = "Frequent acquirer - high integration complexity" if acquisition_frequency > 0.7 else "Moderate acquisition frequency" if acquisition_frequency > 0.3 else "Infrequent acquisitions"+ frequency_risk = RiskLevel.HIGH if acquisition_frequency > 0.8 else RiskLevel.MODERATE if acquisition_frequency > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Acquisition Frequency",+ value=acquisition_frequency,+ interpretation=frequency_interpretation,+ risk_level=frequency_risk,+ methodology="Periods with Acquisitions / Total Periods"+ ))++ return results++ def _analyze_spe_vie(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze Special Purpose Entities and Variable Interest Entities"""+ results = []++ notes = statements.notes++ # VIE Analysis+ vie_assets = notes.get('vie_consolidated_assets', 0)+ vie_liabilities = notes.get('vie_consolidated_liabilities', 0)+ unconsolidated_vie_exposure = notes.get('unconsolidated_vie_exposure', 0)++ total_assets = statements.balance_sheet.get('total_assets', 0)++ # Consolidated VIE Analysis+ if vie_assets > 0 and total_assets > 0:+ vie_asset_ratio = self.safe_divide(vie_assets, total_assets)++ vie_interpretation = "Significant VIE consolidation impact" if vie_asset_ratio > 0.2 else "Moderate VIE consolidation" if vie_asset_ratio > 0.1 else "Limited VIE consolidation"+ vie_risk = RiskLevel.MODERATE if vie_asset_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="VIE Asset Consolidation Ratio",+ value=vie_asset_ratio,+ interpretation=vie_interpretation,+ risk_level=vie_risk,+ methodology="VIE Consolidated Assets / Total Assets",+ limitations=["VIE consolidation may obscure underlying business performance"]+ ))++ # Unconsolidated VIE Exposure+ if unconsolidated_vie_exposure > 0:+ if total_assets > 0:+ vie_exposure_ratio = self.safe_divide(unconsolidated_vie_exposure, total_assets)++ exposure_interpretation = "Significant off-balance sheet VIE exposure" if vie_exposure_ratio > 0.1 else "Moderate off-balance sheet exposure" if vie_exposure_ratio > 0.05 else "Limited off-balance sheet VIE exposure"+ exposure_risk = RiskLevel.HIGH if vie_exposure_ratio > 0.2 else RiskLevel.MODERATE if vie_exposure_ratio > 0.1 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Unconsolidated VIE Exposure",+ value=vie_exposure_ratio,+ interpretation=exposure_interpretation,+ risk_level=exposure_risk,+ methodology="Unconsolidated VIE Exposure / Total Assets",+ limitations=["Off-balance sheet exposures may represent hidden risks"]+ ))++ # SPE Disclosure Quality+ spe_disclosures = sum(1 for key in notes.keys() if+ 'spe' in key.lower() or 'vie' in key.lower() or 'special_purpose' in key.lower())++ if spe_disclosures > 0:+ disclosure_interpretation = "Comprehensive SPE/VIE disclosures" if spe_disclosures > 5 else "Adequate SPE/VIE disclosures" if spe_disclosures > 2 else "Limited SPE/VIE disclosures"+ disclosure_risk = RiskLevel.LOW if spe_disclosures > 3 else RiskLevel.MODERATE if spe_disclosures > 1 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="SPE/VIE Disclosure Quality",+ value=spe_disclosures,+ interpretation=disclosure_interpretation,+ risk_level=disclosure_risk,+ methodology="Count of SPE/VIE related disclosures"+ ))++ return results++ def _analyze_gaap_differences(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Analyze IFRS vs US GAAP differences in intercorporate investments"""+ results = []++ reporting_standard = statements.company_info.reporting_standard+ notes = statements.notes++ # Classification and Measurement Differences+ if reporting_standard == ReportingStandard.IFRS:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="IFRS Investment Classification",+ value=1.0,+ interpretation="Under IFRS 9, financial assets classified based on business model and cash flow characteristics",+ risk_level=RiskLevel.LOW,+ methodology="IFRS 9 classification assessment",+ limitations=["IFRS allows more judgment in classification decisions"]+ ))++ elif reporting_standard == ReportingStandard.US_GAAP:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="US GAAP Investment Classification",+ value=1.0,+ interpretation="Under US GAAP, financial assets follow traditional held-to-maturity, available-for-sale, and trading classifications",+ risk_level=RiskLevel.LOW,+ methodology="US GAAP classification assessment",+ limitations=["US GAAP has more prescriptive classification rules"]+ ))++ # Joint Venture Accounting Differences+ joint_ventures = statements.balance_sheet.get('investments_in_joint_ventures', 0)++ if joint_ventures > 0:+ if reporting_standard == ReportingStandard.IFRS:+ jv_interpretation = "Under IFRS 11, joint ventures must use equity method (proportionate consolidation eliminated)"+ else:+ jv_interpretation = "Under US GAAP, joint ventures typically use equity method"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Joint Venture Accounting Method",+ value=1.0,+ interpretation=jv_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Assessment of joint venture accounting standards"+ ))++ return results++ def _assess_investment_strategy(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Assess overall intercorporate investment strategy"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ # Total Investment Portfolio Analysis+ total_investments = (+ balance_sheet.get('trading_securities', 0) ++ balance_sheet.get('available_for_sale_securities', 0) ++ balance_sheet.get('held_to_maturity_securities', 0) ++ balance_sheet.get('investments_in_associates', 0) ++ balance_sheet.get('investments_in_joint_ventures', 0)+ )++ total_assets = balance_sheet.get('total_assets', 0)++ if total_investments > 0 and total_assets > 0:+ total_investment_ratio = self.safe_divide(total_investments, total_assets)++ strategy_interpretation = "Investment-intensive business model" if total_investment_ratio > 0.4 else "Moderate investment strategy" if total_investment_ratio > 0.2 else "Limited investment focus"+ strategy_risk = RiskLevel.MODERATE if total_investment_ratio > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Total Investment Intensity",+ value=total_investment_ratio,+ interpretation=strategy_interpretation,+ risk_level=strategy_risk,+ methodology="Total Intercorporate Investments / Total Assets"+ ))++ # Investment Diversification Analysis+ investment_types = {+ 'Financial Assets': balance_sheet.get('trading_securities', 0) + balance_sheet.get(+ 'available_for_sale_securities', 0),+ 'Associates': balance_sheet.get('investments_in_associates', 0),+ 'Joint Ventures': balance_sheet.get('investments_in_joint_ventures', 0)+ }++ non_zero_types = sum(1 for value in investment_types.values() if value > 0)++ if non_zero_types > 0:+ diversification_interpretation = "Well-diversified investment portfolio" if non_zero_types >= 3 else "Moderately diversified investments" if non_zero_types == 2 else "Concentrated investment strategy"+ diversification_risk = RiskLevel.LOW if non_zero_types >= 3 else RiskLevel.MODERATE if non_zero_types == 2 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Investment Diversification",+ value=non_zero_types,+ interpretation=diversification_interpretation,+ risk_level=diversification_risk,+ methodology="Count of different investment types with material balances"+ ))++ # Investment Performance vs Core Business+ total_investment_income = (+ income_statement.get('investment_income', 0) ++ income_statement.get('share_of_associate_profits', 0) ++ income_statement.get('share_of_jv_profits', 0)+ )++ operating_income = income_statement.get('operating_income', 0)++ if operating_income > 0 and total_investment_income != 0:+ investment_contribution = self.safe_divide(total_investment_income, operating_income)++ contribution_interpretation = "Investments significantly contribute to earnings" if investment_contribution > 0.3 else "Moderate investment contribution" if investment_contribution > 0.1 else "Limited investment contribution to earnings"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Investment Earnings Contribution",+ value=investment_contribution,+ interpretation=contribution_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Total Investment Income / Operating Income"+ ))++ return results++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key intercorporate investment metrics"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ metrics = {}++ # Investment intensities+ total_assets = balance_sheet.get('total_assets', 0)++ if total_assets > 0:+ financial_assets = (+ balance_sheet.get('trading_securities', 0) ++ balance_sheet.get('available_for_sale_securities', 0) ++ balance_sheet.get('held_to_maturity_securities', 0)+ )+ metrics['financial_asset_intensity'] = self.safe_divide(financial_assets, total_assets)++ associates = balance_sheet.get('investments_in_associates', 0)+ metrics['associate_intensity'] = self.safe_divide(associates, total_assets)++ joint_ventures = balance_sheet.get('investments_in_joint_ventures', 0)+ metrics['joint_venture_intensity'] = self.safe_divide(joint_ventures, total_assets)++ total_investments = financial_assets + associates + joint_ventures+ metrics['total_investment_intensity'] = self.safe_divide(total_investments, total_assets)++ # Investment returns+ associate_investments = balance_sheet.get('investments_in_associates', 0)+ if associate_investments > 0:+ share_of_profits = income_statement.get('share_of_associate_profits', 0)+ metrics['equity_method_return'] = self.safe_divide(share_of_profits, associate_investments)++ jv_investments = balance_sheet.get('investments_in_joint_ventures', 0)+ if jv_investments > 0:+ jv_profits = income_statement.get('share_of_jv_profits', 0)+ metrics['joint_venture_return'] = self.safe_divide(jv_profits, jv_investments)++ # Goodwill metrics+ goodwill = balance_sheet.get('goodwill', 0)+ if total_assets > 0:+ metrics['goodwill_intensity'] = self.safe_divide(goodwill, total_assets)++ return metrics++ def create_financial_asset_analysis(self, statements: FinancialStatements) -> FinancialAssetAnalysis:+ """Create comprehensive financial asset analysis object"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ # Extract financial asset components+ classification_breakdown = {+ 'trading_securities': balance_sheet.get('trading_securities', 0),+ 'available_for_sale': balance_sheet.get('available_for_sale_securities', 0),+ 'held_to_maturity': balance_sheet.get('held_to_maturity_securities', 0),+ 'fvtpl_assets': balance_sheet.get('fvtpl_financial_assets', 0),+ 'fvoci_assets': balance_sheet.get('fvoci_financial_assets', 0),+ 'amortized_cost': balance_sheet.get('amortized_cost_financial_assets', 0)+ }++ total_financial_assets = sum(classification_breakdown.values())++ # Calculate fair value vs amortized cost+ fair_value_assets = (+ classification_breakdown['trading_securities'] ++ classification_breakdown['available_for_sale'] ++ classification_breakdown['fvtpl_assets'] ++ classification_breakdown['fvoci_assets']+ )++ amortized_cost_assets = (+ classification_breakdown['held_to_maturity'] ++ classification_breakdown['amortized_cost']+ )++ # Investment performance metrics+ investment_income = income_statement.get('investment_income', 0)+ realized_gains = income_statement.get('realized_investment_gains', 0)+ unrealized_gains = income_statement.get('unrealized_investment_gains', 0)++ investment_returns = self.safe_divide(investment_income + realized_gains,+ total_financial_assets) if total_financial_assets > 0 else 0+ dividend_income = income_statement.get('dividend_income', 0)++ # Risk assessment (simplified)+ market_risk_exposure = self.safe_divide(fair_value_assets,+ total_financial_assets) if total_financial_assets > 0 else 0++ liquidity_risk = RiskLevel.LOW if amortized_cost_assets > fair_value_assets else RiskLevel.MODERATE if market_risk_exposure < 0.7 else RiskLevel.HIGH++ return FinancialAssetAnalysis(+ total_financial_assets=total_financial_assets,+ classification_breakdown=classification_breakdown,+ fair_value_assets=fair_value_assets,+ amortized_cost_assets=amortized_cost_assets,+ unrealized_gains_losses=unrealized_gains,+ market_risk_exposure=market_risk_exposure,+ liquidity_risk=liquidity_risk,+ investment_returns=investment_returns,+ dividend_income=dividend_income+ )++ def create_associate_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> AssociateAnalysis:+ """Create comprehensive associate analysis object"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ total_associate_investments = balance_sheet.get('investments_in_associates', 0)+ number_of_associates = notes.get('number_of_associates', 1) # Default to 1 if not disclosed++ share_of_profits_losses = income_statement.get('share_of_associate_profits', 0)+ dividend_income_associates = income_statement.get('dividends_from_associates', 0)++ # Calculate carrying value change+ carrying_value_change = 0+ if comparative_data and len(comparative_data) > 0:+ prev_investments = comparative_data[-1].balance_sheet.get('investments_in_associates', 0)+ carrying_value_change = total_associate_investments - prev_investments++ # Performance metrics+ associate_roe = self.safe_divide(share_of_profits_losses,+ total_associate_investments) if total_associate_investments > 0 else 0++ # Trend analysis+ associate_performance_trend = TrendDirection.STABLE+ if comparative_data and len(comparative_data) >= 2:+ profit_values = []+ for past_statements in comparative_data:+ past_profits = past_statements.income_statement.get('share_of_associate_profits', 0)+ profit_values.append(past_profits)+ profit_values.append(share_of_profits_losses)++ if len(profit_values) >= 3:+ if profit_values[-1] > profit_values[0] * 1.1:+ associate_performance_trend = TrendDirection.IMPROVING+ elif profit_values[-1] < profit_values[0] * 0.9:+ associate_performance_trend = TrendDirection.DETERIORATING++ # Impairment indicators+ impairment_indicators = []+ if share_of_profits_losses < 0:+ impairment_indicators.append("Associates generating losses")+ if associate_roe < 0.05 and associate_roe > 0:+ impairment_indicators.append("Low return on associate investments")++ return AssociateAnalysis(+ total_associate_investments=total_associate_investments,+ number_of_associates=number_of_associates,+ share_of_profits_losses=share_of_profits_losses,+ dividend_income_associates=dividend_income_associates,+ carrying_value_change=carrying_value_change,+ associate_roe=associate_roe,+ associate_performance_trend=associate_performance_trend,+ impairment_indicators=impairment_indicators+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/inventory_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/inventory_analysis.pynew file mode 100644index 000000000..cf67c6956--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/inventory_analysis.py@@ -0,0 +1,977 @@++"""+Financial Statement Inventory Analysis Module+========================================++Inventory analysis and working capital assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class InventoryMethod(Enum):+ """Inventory valuation methods"""+ FIFO = "fifo"+ LIFO = "lifo"+ WEIGHTED_AVERAGE = "weighted_average"+ SPECIFIC_IDENTIFICATION = "specific_identification"+++class InventoryType(Enum):+ """Types of inventory"""+ RAW_MATERIALS = "raw_materials"+ WORK_IN_PROCESS = "work_in_process"+ FINISHED_GOODS = "finished_goods"+ MERCHANDISE = "merchandise"+ TOTAL = "total"+++class EconomicEnvironment(Enum):+ """Economic environment classification"""+ INFLATIONARY = "inflationary"+ DEFLATIONARY = "deflationary"+ STABLE = "stable"+++@dataclass+class InventoryValuationAnalysis:+ """Comprehensive inventory valuation analysis"""+ cost_method: InventoryMethod+ current_inventory_value: float+ inventory_reserve: float+ net_realizable_value: float+ lower_of_cost_nrv: float++ # Valuation impact analysis+ fifo_equivalent_value: float = None+ lifo_equivalent_value: float = None+ lifo_reserve: float = None++ # Quality indicators+ inventory_quality_score: float = 0.0+ obsolescence_indicators: List[str] = field(default_factory=list)+ valuation_concerns: List[str] = field(default_factory=list)+++@dataclass+class InventoryEfficiencyAnalysis:+ """Inventory efficiency and turnover analysis"""+ inventory_turnover: float+ days_inventory_outstanding: float+ inventory_to_sales_ratio: float+ inventory_growth_rate: float++ # Trend analysis+ turnover_trend: TrendDirection+ efficiency_score: float++ # Comparative metrics+ industry_comparison: str = None+ seasonal_adjustments: float = None+++@dataclass+class InflationImpactAnalysis:+ """Analysis of inflation/deflation effects on inventory"""+ economic_environment: EconomicEnvironment+ inflation_rate: float++ # FIFO vs LIFO impacts+ fifo_impact_on_cogs: float+ fifo_impact_on_gross_margin: float+ fifo_impact_on_inventory_value: float++ lifo_impact_on_cogs: float+ lifo_impact_on_gross_margin: float+ lifo_impact_on_inventory_value: float++ # Tax implications+ tax_advantage_method: str+ estimated_tax_benefit: float = None+++class InventoryAnalyzer(BaseAnalyzer):+ """+ Comprehensive inventory analyzer implementing CFA Institute standards.+ Covers valuation methods, efficiency analysis, and inflation impact assessment.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_inventory_formulas()+ self._initialize_inventory_benchmarks()++ def _initialize_inventory_formulas(self):+ """Initialize inventory-specific formulas"""+ self.formula_registry.update({+ 'inventory_turnover': lambda cogs, avg_inventory: self.safe_divide(cogs, avg_inventory),+ 'days_inventory_outstanding': lambda avg_inventory, daily_cogs: self.safe_divide(avg_inventory, daily_cogs),+ 'inventory_to_sales': lambda inventory, revenue: self.safe_divide(inventory, revenue),+ 'gross_margin_fifo': lambda revenue, cogs_fifo: self.safe_divide(revenue - cogs_fifo, revenue),+ 'gross_margin_lifo': lambda revenue, cogs_lifo: self.safe_divide(revenue - cogs_lifo, revenue),+ 'lifo_reserve_ratio': lambda lifo_reserve, total_inventory: self.safe_divide(lifo_reserve, total_inventory)+ })++ def _initialize_inventory_benchmarks(self):+ """Initialize inventory-specific benchmarks"""+ # Industry-dependent benchmarks (these are general guidelines)+ self.inventory_benchmarks = {+ 'inventory_turnover': {+ 'retail': {'excellent': 12.0, 'good': 8.0, 'adequate': 6.0, 'poor': 4.0},+ 'manufacturing': {'excellent': 8.0, 'good': 6.0, 'adequate': 4.0, 'poor': 2.0},+ 'general': {'excellent': 10.0, 'good': 7.0, 'adequate': 5.0, 'poor': 3.0}+ },+ 'days_inventory_outstanding': {+ 'retail': {'excellent': 30, 'good': 45, 'adequate': 60, 'poor': 90},+ 'manufacturing': {'excellent': 45, 'good': 60, 'adequate': 90, 'poor': 120},+ 'general': {'excellent': 36, 'good': 52, 'adequate': 73, 'poor': 120}+ },+ 'inventory_to_sales': {+ 'retail': {'excellent': 0.08, 'good': 0.12, 'adequate': 0.15, 'poor': 0.20},+ 'manufacturing': {'excellent': 0.15, 'good': 0.20, 'adequate': 0.25, 'poor': 0.35},+ 'general': {'excellent': 0.10, 'good': 0.15, 'adequate': 0.20, 'poor': 0.30}+ }+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive inventory analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all inventory aspects+ """+ results = []++ # Check if inventory analysis is applicable+ inventory = statements.balance_sheet.get('inventory', 0)+ if inventory <= 0:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Inventory Analysis",+ value=0.0,+ interpretation="No inventory reported - inventory analysis not applicable",+ risk_level=RiskLevel.LOW,+ methodology="Balance sheet inventory examination"+ ))+ return results++ # Core inventory efficiency analysis+ results.extend(self._analyze_inventory_efficiency(statements, comparative_data, industry_data))++ # Inventory valuation analysis+ results.extend(self._analyze_inventory_valuation(statements, comparative_data))++ # Lower of cost and NRV analysis+ results.extend(self._analyze_lower_cost_nrv(statements, comparative_data))++ # Inflation/deflation impact analysis+ results.extend(self._analyze_inflation_impact(statements, comparative_data, industry_data))++ # Inventory composition analysis+ results.extend(self._analyze_inventory_composition(statements))++ # Disclosure quality assessment+ results.extend(self._assess_inventory_disclosures(statements))++ return results++ def _analyze_inventory_efficiency(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze inventory efficiency and turnover metrics"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ inventory = balance_sheet.get('inventory', 0)+ cost_of_sales = income_statement.get('cost_of_sales', 0)+ revenue = income_statement.get('revenue', 0)++ # Calculate average inventory if historical data available+ avg_inventory = inventory+ if comparative_data and len(comparative_data) > 0:+ prev_inventory = comparative_data[-1].balance_sheet.get('inventory', 0)+ if prev_inventory > 0:+ avg_inventory = (inventory + prev_inventory) / 2++ # Inventory Turnover Ratio+ if avg_inventory > 0 and cost_of_sales > 0:+ inventory_turnover = self.safe_divide(cost_of_sales, avg_inventory)++ # Get appropriate benchmark+ industry_type = industry_data.get('type', 'general') if industry_data else 'general'+ benchmark = self.inventory_benchmarks['inventory_turnover'].get(industry_type,+ self.inventory_benchmarks[+ 'inventory_turnover']['general'])++ risk_level = self.assess_risk_level(inventory_turnover, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Inventory Turnover",+ value=inventory_turnover,+ interpretation=self.generate_interpretation("inventory turnover", inventory_turnover, risk_level,+ AnalysisType.ACTIVITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(inventory_turnover, industry_data.get(+ 'inventory_turnover') if industry_data else None),+ methodology="Cost of Goods Sold / Average Inventory",+ limitations=["Seasonality may affect single-period calculations"]+ ))++ # Days Inventory Outstanding (DIO)+ if avg_inventory > 0 and cost_of_sales > 0:+ daily_cogs = cost_of_sales / 365+ days_inventory = self.safe_divide(avg_inventory, daily_cogs)++ # Get appropriate benchmark+ benchmark = self.inventory_benchmarks['days_inventory_outstanding'].get(industry_type,+ self.inventory_benchmarks[+ 'days_inventory_outstanding'][+ 'general'])++ risk_level = self.assess_risk_level(days_inventory, benchmark, higher_is_better=False)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Days Inventory Outstanding",+ value=days_inventory,+ interpretation=f"Inventory held for {days_inventory:.0f} days on average",+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(days_inventory, industry_data.get(+ 'days_inventory') if industry_data else None),+ methodology="(Average Inventory / COGS) × 365",+ limitations=["Does not account for seasonal inventory patterns"]+ ))++ # Inventory to Sales Ratio+ if revenue > 0:+ inventory_to_sales = self.safe_divide(inventory, revenue)++ benchmark = self.inventory_benchmarks['inventory_to_sales'].get(industry_type,+ self.inventory_benchmarks[+ 'inventory_to_sales']['general'])++ risk_level = self.assess_risk_level(inventory_to_sales, benchmark, higher_is_better=False)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Inventory to Sales Ratio",+ value=inventory_to_sales,+ interpretation=f"Inventory represents {self.format_percentage(inventory_to_sales)} of annual sales",+ risk_level=risk_level,+ methodology="Ending Inventory / Revenue",+ limitations=["Point-in-time measure may not reflect average levels"]+ ))++ # Inventory growth analysis+ if comparative_data and len(comparative_data) > 0:+ prev_inventory = comparative_data[-1].balance_sheet.get('inventory', 0)+ prev_revenue = comparative_data[-1].income_statement.get('revenue', 0)++ if prev_inventory > 0:+ inventory_growth = (inventory / prev_inventory) - 1++ if prev_revenue > 0:+ revenue_growth = (revenue / prev_revenue) - 1++ # Compare inventory growth to sales growth+ if abs(revenue_growth) > 0.01: # Avoid division by very small numbers+ growth_comparison = inventory_growth - revenue_growth++ if growth_comparison > 0.1:+ growth_interpretation = "Inventory growing faster than sales - potential build-up"+ growth_risk = RiskLevel.MODERATE+ elif growth_comparison < -0.1:+ growth_interpretation = "Inventory growing slower than sales - improving efficiency"+ growth_risk = RiskLevel.LOW+ else:+ growth_interpretation = "Inventory growth aligned with sales growth"+ growth_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Inventory vs Sales Growth",+ value=growth_comparison,+ interpretation=growth_interpretation,+ risk_level=growth_risk,+ methodology="Inventory Growth Rate - Revenue Growth Rate",+ limitations=["Single period comparison - trend analysis preferred"]+ ))++ return results++ def _analyze_inventory_valuation(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze inventory valuation methods and their impact"""+ results = []++ notes = statements.notes+ balance_sheet = statements.balance_sheet++ inventory = balance_sheet.get('inventory', 0)++ # Check for LIFO reserve disclosure+ lifo_reserve = notes.get('lifo_reserve', 0)++ if lifo_reserve > 0:+ # LIFO Reserve Analysis+ lifo_reserve_ratio = self.safe_divide(lifo_reserve, inventory)++ reserve_interpretation = "Significant LIFO reserve indicates substantial inflation impact" if lifo_reserve_ratio > 0.2 else "Moderate LIFO reserve" if lifo_reserve_ratio > 0.1 else "Small LIFO reserve impact"+ reserve_risk = RiskLevel.MODERATE if lifo_reserve_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="LIFO Reserve Ratio",+ value=lifo_reserve_ratio,+ interpretation=reserve_interpretation,+ risk_level=reserve_risk,+ methodology="LIFO Reserve / Total Inventory",+ limitations=["LIFO reserve represents cumulative impact over multiple periods"]+ ))++ # FIFO-equivalent inventory value+ fifo_equivalent_inventory = inventory + lifo_reserve+ fifo_adjustment_ratio = self.safe_divide(lifo_reserve, inventory)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="FIFO Equivalent Adjustment",+ value=fifo_adjustment_ratio,+ interpretation=f"FIFO inventory would be {self.format_percentage(fifo_adjustment_ratio)} higher than LIFO",+ risk_level=RiskLevel.LOW,+ methodology="LIFO Reserve / LIFO Inventory",+ limitations=["Adjustment provides approximate FIFO equivalent"]+ ))++ # Inventory method impact analysis+ cost_method = notes.get('inventory_method', 'unknown')+ if cost_method != 'unknown':+ method_risk_assessment = self._assess_method_appropriateness(cost_method, statements)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inventory Method Assessment",+ value=1.0,+ interpretation=f"Company uses {cost_method} method - {method_risk_assessment['assessment']}",+ risk_level=method_risk_assessment['risk'],+ methodology="Qualitative assessment of inventory method appropriateness",+ limitations=method_risk_assessment['limitations']+ ))++ return results++ def _analyze_lower_cost_nrv(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze lower of cost and net realizable value measurements"""+ results = []++ balance_sheet = statements.balance_sheet+ notes = statements.notes++ inventory = balance_sheet.get('inventory', 0)+ inventory_writedown = notes.get('inventory_writedown', 0)+ inventory_reserve = notes.get('inventory_obsolescence_reserve', 0)++ # Inventory writedown analysis+ if inventory_writedown > 0:+ writedown_ratio = self.safe_divide(inventory_writedown, inventory + inventory_writedown)++ writedown_interpretation = "Significant inventory writedown indicates valuation issues" if writedown_ratio > 0.05 else "Moderate inventory adjustment" if writedown_ratio > 0.02 else "Minor inventory writedown"+ writedown_risk = RiskLevel.HIGH if writedown_ratio > 0.1 else RiskLevel.MODERATE if writedown_ratio > 0.05 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inventory Writedown Impact",+ value=writedown_ratio,+ interpretation=writedown_interpretation,+ risk_level=writedown_risk,+ methodology="Inventory Writedown / (Inventory + Writedown)",+ limitations=["Writedowns may indicate obsolescence or market decline"]+ ))++ # Obsolescence reserve analysis+ if inventory_reserve > 0:+ reserve_ratio = self.safe_divide(inventory_reserve, inventory + inventory_reserve)++ reserve_interpretation = "High obsolescence reserve suggests inventory quality concerns" if reserve_ratio > 0.1 else "Moderate obsolescence provision" if reserve_ratio > 0.05 else "Conservative obsolescence reserve"+ reserve_risk = RiskLevel.MODERATE if reserve_ratio > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Obsolescence Reserve Ratio",+ value=reserve_ratio,+ interpretation=reserve_interpretation,+ risk_level=reserve_risk,+ methodology="Obsolescence Reserve / (Inventory + Reserve)",+ limitations=["Reserve adequacy depends on inventory composition and age"]+ ))++ # NRV compliance assessment+ results.extend(self._assess_nrv_compliance(statements, comparative_data))++ return results++ def _analyze_inflation_impact(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze impact of inflation/deflation on inventory and ratios"""+ results = []++ notes = statements.notes+ income_statement = statements.income_statement++ # Determine economic environment+ inflation_rate = industry_data.get('inflation_rate', 0) if industry_data else 0+ economic_environment = self._determine_economic_environment(inflation_rate)++ cost_method = notes.get('inventory_method', 'unknown')+ lifo_reserve = notes.get('lifo_reserve', 0)++ if economic_environment != EconomicEnvironment.STABLE and cost_method in ['fifo', 'lifo']:+ # Inflation impact on COGS and margins+ revenue = income_statement.get('revenue', 0)+ cost_of_sales = income_statement.get('cost_of_sales', 0)++ if revenue > 0 and cost_of_sales > 0:+ current_gross_margin = self.safe_divide(revenue - cost_of_sales, revenue)++ # Estimate impact of different methods+ if cost_method == 'lifo' and lifo_reserve > 0:+ # Estimate FIFO COGS+ estimated_fifo_cogs = cost_of_sales - lifo_reserve # Simplified estimation+ estimated_fifo_margin = self.safe_divide(revenue - estimated_fifo_cogs, revenue)++ margin_impact = estimated_fifo_margin - current_gross_margin++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inflation Method Impact",+ value=margin_impact,+ interpretation=f"FIFO would result in {self.format_percentage(abs(margin_impact))} {'higher' if margin_impact > 0 else 'lower'} gross margin",+ risk_level=RiskLevel.MODERATE if abs(margin_impact) > 0.05 else RiskLevel.LOW,+ methodology="Estimated FIFO margin - Current LIFO margin",+ limitations=["Estimation based on LIFO reserve approximation"]+ ))++ # Tax implications+ if economic_environment == EconomicEnvironment.INFLATIONARY:+ tax_preferred_method = "LIFO" if cost_method == 'lifo' else "LIFO (not used)"+ tax_impact_description = "LIFO provides tax benefits in inflationary environment" if cost_method == 'lifo' else "FIFO results in higher taxable income during inflation"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Method Efficiency",+ value=1.0 if cost_method == 'lifo' else 0.0,+ interpretation=tax_impact_description,+ risk_level=RiskLevel.LOW if cost_method == 'lifo' else RiskLevel.MODERATE,+ methodology="Qualitative assessment of method choice in inflationary environment"+ ))++ return results++ def _analyze_inventory_composition(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Analyze inventory composition and mix"""+ results = []++ notes = statements.notes+ balance_sheet = statements.balance_sheet++ total_inventory = balance_sheet.get('inventory', 0)++ # Analyze inventory components if disclosed+ inventory_components = {+ 'raw_materials': notes.get('raw_materials_inventory', 0),+ 'work_in_process': notes.get('wip_inventory', 0),+ 'finished_goods': notes.get('finished_goods_inventory', 0)+ }++ total_components = sum(inventory_components.values())++ if total_components > 0 and abs(total_components - total_inventory) / total_inventory < 0.1:+ # Composition analysis+ for component, value in inventory_components.items():+ if value > 0:+ component_ratio = self.safe_divide(value, total_inventory)++ component_name = component.replace('_', ' ').title()++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name=f"{component_name} Composition",+ value=component_ratio,+ interpretation=f"{component_name} represents {self.format_percentage(component_ratio)} of total inventory",+ risk_level=RiskLevel.LOW,+ methodology=f"{component_name} / Total Inventory"+ ))++ # Risk assessment based on composition+ raw_materials_ratio = inventory_components['raw_materials'] / total_inventory+ wip_ratio = inventory_components['work_in_process'] / total_inventory+ finished_goods_ratio = inventory_components['finished_goods'] / total_inventory++ if wip_ratio > 0.5:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inventory Composition Risk",+ value=wip_ratio,+ interpretation="High work-in-process ratio may indicate production inefficiencies",+ risk_level=RiskLevel.MODERATE,+ methodology="Qualitative assessment of inventory composition"+ ))+ elif finished_goods_ratio > 0.7:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inventory Composition Risk",+ value=finished_goods_ratio,+ interpretation="High finished goods ratio may indicate demand forecasting issues",+ risk_level=RiskLevel.MODERATE,+ methodology="Qualitative assessment of inventory composition"+ ))++ return results++ def _assess_inventory_disclosures(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Assess quality and completeness of inventory disclosures"""+ results = []++ notes = statements.notes++ # Required disclosure checklist+ required_disclosures = {+ 'inventory_method': 'Accounting policy for inventory valuation',+ 'inventory_composition': 'Breakdown of inventory components',+ 'writedown_policy': 'Policy for inventory writedowns',+ 'obsolescence_assessment': 'Obsolescence evaluation methodology'+ }++ disclosure_score = 0+ missing_disclosures = []++ for disclosure_key, description in required_disclosures.items():+ if any(disclosure_key in key.lower() for key in notes.keys()):+ disclosure_score += 25+ else:+ missing_disclosures.append(description)++ disclosure_interpretation = "Comprehensive inventory disclosures" if disclosure_score > 75 else "Adequate inventory disclosures" if disclosure_score > 50 else "Limited inventory disclosures"+ disclosure_risk = RiskLevel.LOW if disclosure_score > 75 else RiskLevel.MODERATE if disclosure_score > 50 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Inventory Disclosure Quality",+ value=disclosure_score,+ interpretation=disclosure_interpretation,+ risk_level=disclosure_risk,+ methodology="Assessment of required inventory disclosure completeness",+ limitations=missing_disclosures if missing_disclosures else [+ "Disclosure quality assessment based on available notes"]+ ))++ return results++ def _assess_method_appropriateness(self, method: str, statements: FinancialStatements) -> Dict[+ str, Union[str, RiskLevel, List[str]]]:+ """Assess appropriateness of inventory method choice"""++ notes = statements.notes++ # Industry and business considerations+ business_type = notes.get('business_description', '').lower()++ if method.lower() == 'fifo':+ if 'perishable' in business_type or 'food' in business_type:+ return {+ 'assessment': 'FIFO appropriate for perishable goods business',+ 'risk': RiskLevel.LOW,+ 'limitations': ['FIFO reflects physical flow for perishables']+ }+ else:+ return {+ 'assessment': 'FIFO provides current cost basis for inventory',+ 'risk': RiskLevel.LOW,+ 'limitations': ['FIFO may overstate profits during inflation']+ }++ elif method.lower() == 'lifo':+ return {+ 'assessment': 'LIFO provides tax benefits in inflationary periods',+ 'risk': RiskLevel.LOW,+ 'limitations': ['LIFO may understate inventory values', 'Not permitted under IFRS']+ }++ elif method.lower() == 'weighted_average':+ return {+ 'assessment': 'Weighted average smooths cost fluctuations',+ 'risk': RiskLevel.LOW,+ 'limitations': ['May not reflect specific cost identification']+ }++ else:+ return {+ 'assessment': 'Method appropriateness cannot be assessed',+ 'risk': RiskLevel.MODERATE,+ 'limitations': ['Insufficient information on inventory method']+ }++ def _assess_nrv_compliance(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Assess compliance with lower of cost and NRV requirements"""+ results = []++ notes = statements.notes+ income_statement = statements.income_statement++ # Look for NRV-related disclosures+ nrv_writedowns = notes.get('nrv_writedowns', 0)+ inventory_impairment = income_statement.get('inventory_impairment', 0)++ if nrv_writedowns > 0 or inventory_impairment > 0:+ total_writedowns = nrv_writedowns + inventory_impairment++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="NRV Writedown Activity",+ value=total_writedowns,+ interpretation=f"NRV writedowns of ${total_writedowns:,.0f} indicate active impairment monitoring",+ risk_level=RiskLevel.MODERATE if total_writedowns > 0 else RiskLevel.LOW,+ methodology="Sum of NRV writedowns and inventory impairments",+ limitations=["Writedowns may indicate market deterioration or obsolescence"]+ ))++ # Assess NRV methodology disclosure+ nrv_policy = notes.get('nrv_methodology', '')+ if nrv_policy:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="NRV Methodology Disclosure",+ value=1.0,+ interpretation="Company discloses NRV assessment methodology",+ risk_level=RiskLevel.LOW,+ methodology="Qualitative assessment of NRV disclosure quality"+ ))+ else:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="NRV Methodology Disclosure",+ value=0.0,+ interpretation="Limited disclosure of NRV assessment methodology",+ risk_level=RiskLevel.MODERATE,+ methodology="Qualitative assessment of NRV disclosure quality",+ limitations=["Lack of NRV methodology disclosure reduces transparency"]+ ))++ return results++ def _determine_economic_environment(self, inflation_rate: float) -> EconomicEnvironment:+ """Determine economic environment based on inflation rate"""+ if inflation_rate > 0.03: # 3% threshold+ return EconomicEnvironment.INFLATIONARY+ elif inflation_rate < -0.01: # -1% threshold+ return EconomicEnvironment.DEFLATIONARY+ else:+ return EconomicEnvironment.STABLE++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key inventory metrics"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ inventory = balance_sheet.get('inventory', 0)+ cost_of_sales = income_statement.get('cost_of_sales', 0)+ revenue = income_statement.get('revenue', 0)++ metrics = {}++ # Core inventory metrics+ if inventory > 0:+ metrics['inventory_value'] = inventory++ if cost_of_sales > 0:+ metrics['inventory_turnover'] = self.safe_divide(cost_of_sales, inventory)+ metrics['days_inventory_outstanding'] = self.safe_divide(inventory * 365, cost_of_sales)++ if revenue > 0:+ metrics['inventory_to_sales'] = self.safe_divide(inventory, revenue)++ # LIFO reserve metrics+ notes = statements.notes+ lifo_reserve = notes.get('lifo_reserve', 0)+ if lifo_reserve > 0:+ metrics['lifo_reserve'] = lifo_reserve+ metrics['lifo_reserve_ratio'] = self.safe_divide(lifo_reserve, inventory)++ return metrics++ def create_inventory_efficiency_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> InventoryEfficiencyAnalysis:+ """Create comprehensive inventory efficiency analysis object"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ inventory = balance_sheet.get('inventory', 0)+ cost_of_sales = income_statement.get('cost_of_sales', 0)+ revenue = income_statement.get('revenue', 0)++ # Calculate average inventory+ avg_inventory = inventory+ if comparative_data and len(comparative_data) > 0:+ prev_inventory = comparative_data[-1].balance_sheet.get('inventory', 0)+ if prev_inventory > 0:+ avg_inventory = (inventory + prev_inventory) / 2++ # Core efficiency metrics+ inventory_turnover = self.safe_divide(cost_of_sales, avg_inventory)+ days_inventory_outstanding = self.safe_divide(avg_inventory * 365, cost_of_sales) if cost_of_sales > 0 else 0+ inventory_to_sales_ratio = self.safe_divide(inventory, revenue)++ # Growth rate calculation+ inventory_growth_rate = 0+ if comparative_data and len(comparative_data) > 0:+ prev_inventory = comparative_data[-1].balance_sheet.get('inventory', 0)+ if prev_inventory > 0:+ inventory_growth_rate = (inventory / prev_inventory) - 1++ # Trend analysis+ turnover_trend = TrendDirection.STABLE+ if comparative_data and len(comparative_data) >= 2:+ turnover_values = []+ for past_statements in comparative_data:+ past_inventory = past_statements.balance_sheet.get('inventory', 0)+ past_cogs = past_statements.income_statement.get('cost_of_sales', 0)+ if past_inventory > 0 and past_cogs > 0:+ turnover_values.append(past_cogs / past_inventory)++ if len(turnover_values) >= 2:+ if turnover_values[-1] > turnover_values[0] * 1.05:+ turnover_trend = TrendDirection.IMPROVING+ elif turnover_values[-1] < turnover_values[0] * 0.95:+ turnover_trend = TrendDirection.DETERIORATING++ # Efficiency score calculation+ efficiency_score = 100+ if inventory_turnover < 4:+ efficiency_score -= 20+ if days_inventory_outstanding > 90:+ efficiency_score -= 15+ if inventory_to_sales_ratio > 0.25:+ efficiency_score -= 10++ efficiency_score = max(0, efficiency_score)++ return InventoryEfficiencyAnalysis(+ inventory_turnover=inventory_turnover,+ days_inventory_outstanding=days_inventory_outstanding,+ inventory_to_sales_ratio=inventory_to_sales_ratio,+ inventory_growth_rate=inventory_growth_rate,+ turnover_trend=turnover_trend,+ efficiency_score=efficiency_score+ )++ def create_inventory_valuation_analysis(self, statements: FinancialStatements) -> InventoryValuationAnalysis:+ """Create comprehensive inventory valuation analysis object"""++ balance_sheet = statements.balance_sheet+ notes = statements.notes++ inventory = balance_sheet.get('inventory', 0)+ cost_method_str = notes.get('inventory_method', 'unknown')++ # Determine cost method+ cost_method = InventoryMethod.FIFO # default+ if 'lifo' in cost_method_str.lower():+ cost_method = InventoryMethod.LIFO+ elif 'weighted' in cost_method_str.lower() or 'average' in cost_method_str.lower():+ cost_method = InventoryMethod.WEIGHTED_AVERAGE+ elif 'specific' in cost_method_str.lower():+ cost_method = InventoryMethod.SPECIFIC_IDENTIFICATION++ # Valuation components+ inventory_reserve = notes.get('inventory_obsolescence_reserve', 0)+ lifo_reserve = notes.get('lifo_reserve', 0)++ # Estimate NRV and lower of cost/NRV+ net_realizable_value = inventory # Would need market data for actual calculation+ lower_of_cost_nrv = inventory - inventory_reserve++ # FIFO/LIFO equivalent calculations+ fifo_equivalent_value = None+ lifo_equivalent_value = None++ if cost_method == InventoryMethod.LIFO and lifo_reserve > 0:+ fifo_equivalent_value = inventory + lifo_reserve+ elif cost_method == InventoryMethod.FIFO and lifo_reserve > 0:+ lifo_equivalent_value = inventory - lifo_reserve++ # Quality assessment+ quality_score = 100+ obsolescence_indicators = []+ valuation_concerns = []++ if inventory_reserve > 0:+ reserve_ratio = inventory_reserve / (inventory + inventory_reserve)+ if reserve_ratio > 0.1:+ quality_score -= 20+ obsolescence_indicators.append("High obsolescence reserve")++ if cost_method == InventoryMethod.LIFO:+ valuation_concerns.append("LIFO may understate current inventory values")++ return InventoryValuationAnalysis(+ cost_method=cost_method,+ current_inventory_value=inventory,+ inventory_reserve=inventory_reserve,+ net_realizable_value=net_realizable_value,+ lower_of_cost_nrv=lower_of_cost_nrv,+ fifo_equivalent_value=fifo_equivalent_value,+ lifo_equivalent_value=lifo_equivalent_value,+ lifo_reserve=lifo_reserve,+ inventory_quality_score=quality_score,+ obsolescence_indicators=obsolescence_indicators,+ valuation_concerns=valuation_concerns+ )++ def create_inflation_impact_analysis(self, statements: FinancialStatements,+ inflation_rate: float = 0.0) -> InflationImpactAnalysis:+ """Create inflation impact analysis object"""++ income_statement = statements.income_statement+ notes = statements.notes++ economic_environment = self._determine_economic_environment(inflation_rate)+ cost_method = notes.get('inventory_method', 'unknown')+ lifo_reserve = notes.get('lifo_reserve', 0)++ revenue = income_statement.get('revenue', 0)+ cost_of_sales = income_statement.get('cost_of_sales', 0)++ # Initialize impact metrics+ fifo_impact_on_cogs = 0+ fifo_impact_on_gross_margin = 0+ fifo_impact_on_inventory_value = 0++ lifo_impact_on_cogs = 0+ lifo_impact_on_gross_margin = 0+ lifo_impact_on_inventory_value = 0++ tax_advantage_method = "No significant difference"++ # Calculate impacts if using LIFO and LIFO reserve available+ if cost_method.lower() == 'lifo' and lifo_reserve > 0 and revenue > 0:+ current_gross_margin = (revenue - cost_of_sales) / revenue++ # Estimate FIFO COGS (simplified)+ estimated_fifo_cogs = cost_of_sales - lifo_reserve+ estimated_fifo_gross_margin = (revenue - estimated_fifo_cogs) / revenue++ fifo_impact_on_cogs = estimated_fifo_cogs - cost_of_sales+ fifo_impact_on_gross_margin = estimated_fifo_gross_margin - current_gross_margin+ fifo_impact_on_inventory_value = lifo_reserve++ if economic_environment == EconomicEnvironment.INFLATIONARY:+ tax_advantage_method = "LIFO provides tax advantage"++ elif cost_method.lower() == 'fifo' and inflation_rate > 0.02:+ # FIFO in inflationary environment+ if economic_environment == EconomicEnvironment.INFLATIONARY:+ tax_advantage_method = "LIFO would provide tax advantage (not used)"++ return InflationImpactAnalysis(+ economic_environment=economic_environment,+ inflation_rate=inflation_rate,+ fifo_impact_on_cogs=fifo_impact_on_cogs,+ fifo_impact_on_gross_margin=fifo_impact_on_gross_margin,+ fifo_impact_on_inventory_value=fifo_impact_on_inventory_value,+ lifo_impact_on_cogs=lifo_impact_on_cogs,+ lifo_impact_on_gross_margin=lifo_impact_on_gross_margin,+ lifo_impact_on_inventory_value=lifo_impact_on_inventory_value,+ tax_advantage_method=tax_advantage_method+ )++ def analyze_inventory_trends(self, current_statements: FinancialStatements,+ comparative_data: List[FinancialStatements]) -> Dict[str, ComparativeAnalysis]:+ """Analyze inventory trends over multiple periods"""++ trends = {}++ if not comparative_data:+ return trends++ # Collect inventory values over time+ inventory_values = []+ turnover_values = []+ periods = []++ for i, statements in enumerate(comparative_data):+ inventory = statements.balance_sheet.get('inventory', 0)+ cogs = statements.income_statement.get('cost_of_sales', 0)++ inventory_values.append(inventory)+ if inventory > 0 and cogs > 0:+ turnover_values.append(cogs / inventory)++ periods.append(f"Period-{len(comparative_data) - i}")++ # Add current period+ current_inventory = current_statements.balance_sheet.get('inventory', 0)+ current_cogs = current_statements.income_statement.get('cost_of_sales', 0)++ inventory_values.append(current_inventory)+ if current_inventory > 0 and current_cogs > 0:+ turnover_values.append(current_cogs / current_inventory)+ periods.append("Current")++ # Calculate trends+ if len(inventory_values) > 1:+ trends['inventory_values'] = self.calculate_trend(inventory_values, periods)++ if len(turnover_values) > 1:+ trends['inventory_turnover'] = self.calculate_trend(turnover_values, periods)++ return trends\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/multinational_operations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/multinational_operations.pynew file mode 100644index 000000000..63aff3467--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/multinational_operations.py@@ -0,0 +1,952 @@++"""+Financial Statement Multinational Operations Module+========================================++Multinational corporation analysis and foreign operations++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class CurrencyExposureType(Enum):+ """Types of currency exposure"""+ TRANSACTION = "transaction_exposure"+ TRANSLATION = "translation_exposure"+ ECONOMIC = "economic_exposure"+++class TranslationMethod(Enum):+ """Foreign currency translation methods"""+ CURRENT_RATE = "current_rate_method"+ TEMPORAL = "temporal_method"+ HYPERINFLATIONARY = "hyperinflationary_adjustment"+++class FunctionalCurrencyDetermination(Enum):+ """Functional currency indicators"""+ LOCAL_CURRENCY = "local_currency"+ PARENT_CURRENCY = "parent_currency"+ THIRD_CURRENCY = "third_currency"+++class HyperinflationIndicator(Enum):+ """Hyperinflationary economy indicators"""+ CUMULATIVE_INFLATION = "cumulative_inflation_100_percent"+ CURRENCY_INDEXATION = "widespread_indexation"+ SHORT_TERM_RATES = "high_short_term_interest_rates"+ PRICE_INSTABILITY = "price_level_instability"+ LOCAL_CURRENCY_REJECTION = "local_currency_avoided"+++@dataclass+class CurrencyExposureAnalysis:+ """Currency exposure analysis results"""+ total_foreign_exposure: float+ exposure_by_currency: Dict[str, float] = field(default_factory=dict)++ # Transaction exposure+ foreign_receivables: float = 0.0+ foreign_payables: float = 0.0+ net_transaction_exposure: float = 0.0++ # Translation exposure+ net_investment_exposure: float = 0.0+ translation_gains_losses: float = 0.0++ # Risk metrics+ currency_concentration_risk: RiskLevel = RiskLevel.LOW+ hedging_effectiveness: float = 0.0+++@dataclass+class TranslationAnalysis:+ """Foreign currency translation analysis"""+ translation_method_used: TranslationMethod+ functional_currencies: List[str] = field(default_factory=list)++ # Translation impacts+ translation_adjustment_oci: float = 0.0+ translation_impact_on_ratios: Dict[str, float] = field(default_factory=dict)++ # Method-specific effects+ current_rate_effects: Dict[str, float] = field(default_factory=dict)+ temporal_method_effects: Dict[str, float] = field(default_factory=dict)++ # Volatility measures+ translation_volatility: float = 0.0+ ratio_stability: RiskLevel = RiskLevel.LOW+++@dataclass+class GeographicSegmentAnalysis:+ """Geographic segment performance analysis"""+ segments_by_region: Dict[str, Dict[str, float]] = field(default_factory=dict)++ # Performance metrics by region+ revenue_by_region: Dict[str, float] = field(default_factory=dict)+ profit_by_region: Dict[str, float] = field(default_factory=dict)+ assets_by_region: Dict[str, float] = field(default_factory=dict)++ # Concentration analysis+ geographic_concentration: float = 0.0+ top_region_dependency: float = 0.0++ # Growth analysis+ emerging_markets_exposure: float = 0.0+ developed_markets_exposure: float = 0.0+++class MultinationalOperationsAnalyzer(BaseAnalyzer):+ """+ Comprehensive multinational operations analyzer implementing CFA Level II standards.+ Covers currency exposure, translation methods, and geographic analysis.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_multinational_formulas()+ self._initialize_currency_benchmarks()++ def _initialize_multinational_formulas(self):+ """Initialize multinational-specific formulas"""+ self.formula_registry.update({+ 'currency_exposure_ratio': lambda foreign_exposure, total_exposure: self.safe_divide(foreign_exposure,+ total_exposure),+ 'translation_volatility': lambda translation_std, avg_translation: self.safe_divide(translation_std,+ abs(avg_translation)),+ 'hedging_ratio': lambda hedged_amount, total_exposure: self.safe_divide(hedged_amount, total_exposure),+ 'geographic_concentration': lambda largest_segment, total_revenue: self.safe_divide(largest_segment,+ total_revenue),+ 'emerging_market_ratio': lambda em_revenue, total_revenue: self.safe_divide(em_revenue, total_revenue),+ 'fx_sensitivity': lambda earnings_change, fx_change: self.safe_divide(earnings_change, fx_change)+ })++ def _initialize_currency_benchmarks(self):+ """Initialize currency exposure benchmarks"""+ self.currency_benchmarks = {+ 'foreign_exposure_ratio': {'low': 0.2, 'moderate': 0.4, 'high': 0.6, 'very_high': 0.8},+ 'currency_concentration': {'diversified': 0.3, 'moderate': 0.5, 'concentrated': 0.7,+ 'very_concentrated': 0.9},+ 'translation_volatility': {'low': 0.1, 'moderate': 0.3, 'high': 0.6, 'very_high': 1.0},+ 'emerging_market_exposure': {'low': 0.1, 'moderate': 0.3, 'high': 0.5, 'very_high': 0.7}+ }++ # Hyperinflationary economy thresholds+ self.hyperinflation_thresholds = {+ 'cumulative_inflation_3_years': 1.0, # 100% over 3 years+ 'annual_inflation_rate': 0.26, # 26% annual rate+ 'currency_devaluation_annual': 0.5 # 50% annual devaluation+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive multinational operations analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all multinational aspects+ """+ results = []++ # Currency exposure analysis+ results.extend(self._analyze_currency_exposure(statements, comparative_data, industry_data))++ # Translation method analysis+ results.extend(self._analyze_translation_methods(statements, comparative_data))++ # Geographic segment analysis+ results.extend(self._analyze_geographic_segments(statements, comparative_data))++ # Hyperinflationary economies+ results.extend(self._analyze_hyperinflationary_economies(statements, comparative_data))++ # Foreign currency hedging+ results.extend(self._analyze_currency_hedging(statements, comparative_data))++ # Impact on financial ratios+ results.extend(self._analyze_ratio_impacts(statements, comparative_data))++ # Sales sustainability analysis+ results.extend(self._analyze_sales_sustainability(statements, comparative_data))++ return results++ def _analyze_currency_exposure(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze foreign currency exposure"""+ results = []++ notes = statements.notes+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ # Extract foreign operations data+ foreign_revenue = notes.get('foreign_revenue', 0)+ foreign_assets = notes.get('foreign_assets', 0)+ foreign_receivables = balance_sheet.get('foreign_receivables', 0)+ foreign_payables = balance_sheet.get('foreign_payables', 0)++ total_revenue = income_statement.get('revenue', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ # Foreign Revenue Exposure+ if total_revenue > 0 and foreign_revenue > 0:+ foreign_revenue_ratio = self.safe_divide(foreign_revenue, total_revenue)+ benchmark = self.currency_benchmarks['foreign_exposure_ratio']++ if foreign_revenue_ratio > benchmark['very_high']:+ exposure_interpretation = "Very high foreign revenue exposure - significant currency risk"+ exposure_risk = RiskLevel.HIGH+ elif foreign_revenue_ratio > benchmark['high']:+ exposure_interpretation = "High foreign revenue exposure"+ exposure_risk = RiskLevel.MODERATE+ elif foreign_revenue_ratio > benchmark['moderate']:+ exposure_interpretation = "Moderate foreign revenue exposure"+ exposure_risk = RiskLevel.MODERATE+ else:+ exposure_interpretation = "Low foreign revenue exposure"+ exposure_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Foreign Revenue Exposure",+ value=foreign_revenue_ratio,+ interpretation=exposure_interpretation,+ risk_level=exposure_risk,+ benchmark_comparison=self.compare_to_industry(foreign_revenue_ratio, industry_data.get(+ 'foreign_revenue_ratio') if industry_data else None),+ methodology="Foreign Revenue / Total Revenue",+ limitations=["Currency exposure depends on hedging strategies and natural hedges"]+ ))++ # Foreign Asset Exposure+ if total_assets > 0 and foreign_assets > 0:+ foreign_asset_ratio = self.safe_divide(foreign_assets, total_assets)++ asset_exposure_interpretation = "Significant foreign asset exposure to translation risk" if foreign_asset_ratio > 0.4 else "Moderate foreign asset exposure" if foreign_asset_ratio > 0.2 else "Limited foreign asset exposure"+ asset_exposure_risk = RiskLevel.MODERATE if foreign_asset_ratio > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Foreign Asset Exposure",+ value=foreign_asset_ratio,+ interpretation=asset_exposure_interpretation,+ risk_level=asset_exposure_risk,+ methodology="Foreign Assets / Total Assets"+ ))++ # Transaction Exposure Analysis+ if foreign_receivables > 0 or foreign_payables > 0:+ net_transaction_exposure = foreign_receivables - foreign_payables++ if total_assets > 0:+ transaction_exposure_ratio = self.safe_divide(abs(net_transaction_exposure), total_assets)++ transaction_interpretation = f"Net transaction {'asset' if net_transaction_exposure > 0 else 'liability'} exposure of {self.format_percentage(transaction_exposure_ratio)} of total assets"+ transaction_risk = RiskLevel.HIGH if transaction_exposure_ratio > 0.1 else RiskLevel.MODERATE if transaction_exposure_ratio > 0.05 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Net Transaction Exposure",+ value=transaction_exposure_ratio,+ interpretation=transaction_interpretation,+ risk_level=transaction_risk,+ methodology="|Foreign Receivables - Foreign Payables| / Total Assets"+ ))++ # Currency Concentration Analysis+ currency_exposures = self._extract_currency_exposures(notes)+ if currency_exposures:+ max_currency_exposure = max(currency_exposures.values())+ total_foreign_exposure = sum(currency_exposures.values())++ if total_foreign_exposure > 0:+ currency_concentration = self.safe_divide(max_currency_exposure, total_foreign_exposure)+ concentration_benchmark = self.currency_benchmarks['currency_concentration']++ if currency_concentration > concentration_benchmark['very_concentrated']:+ concentration_interpretation = "Very high currency concentration risk"+ concentration_risk = RiskLevel.HIGH+ elif currency_concentration > concentration_benchmark['concentrated']:+ concentration_interpretation = "High currency concentration"+ concentration_risk = RiskLevel.MODERATE+ else:+ concentration_interpretation = "Diversified currency exposure"+ concentration_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Currency Concentration Risk",+ value=currency_concentration,+ interpretation=concentration_interpretation,+ risk_level=concentration_risk,+ methodology="Largest Currency Exposure / Total Foreign Exposure"+ ))++ return results++ def _analyze_translation_methods(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze foreign currency translation methods and their impacts"""+ results = []++ notes = statements.notes+ equity_statement = statements.equity_statement+ reporting_standard = statements.company_info.reporting_standard++ # Translation method identification+ translation_method = notes.get('translation_method', 'current_rate')+ functional_currencies = notes.get('functional_currencies', [])++ # Current Rate Method Analysis+ if 'current_rate' in translation_method.lower():+ translation_adjustment = equity_statement.get('translation_adjustment', 0)+ total_equity = statements.balance_sheet.get('total_equity', 0)++ if total_equity > 0 and abs(translation_adjustment) > 0:+ translation_impact = self.safe_divide(abs(translation_adjustment), total_equity)++ impact_interpretation = "Significant translation impact on equity" if translation_impact > 0.1 else "Moderate translation impact" if translation_impact > 0.05 else "Limited translation impact"+ impact_risk = RiskLevel.MODERATE if translation_impact > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Current Rate Translation Impact",+ value=translation_impact,+ interpretation=impact_interpretation,+ risk_level=impact_risk,+ methodology="|Translation Adjustment| / Total Equity",+ limitations=["Current rate method affects balance sheet but not income statement ratios"]+ ))++ # Temporal Method Analysis+ elif 'temporal' in translation_method.lower():+ fx_gains_losses = statements.income_statement.get('foreign_exchange_gains_losses', 0)+ net_income = statements.income_statement.get('net_income', 0)++ if net_income != 0 and abs(fx_gains_losses) > 0:+ fx_impact_on_earnings = self.safe_divide(abs(fx_gains_losses), abs(net_income))++ earnings_impact_interpretation = "Significant FX impact on earnings under temporal method" if fx_impact_on_earnings > 0.2 else "Moderate FX earnings impact" if fx_impact_on_earnings > 0.1 else "Limited FX earnings impact"+ earnings_impact_risk = RiskLevel.HIGH if fx_impact_on_earnings > 0.3 else RiskLevel.MODERATE if fx_impact_on_earnings > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Temporal Method Earnings Impact",+ value=fx_impact_on_earnings,+ interpretation=earnings_impact_interpretation,+ risk_level=earnings_impact_risk,+ methodology="|FX Gains/Losses| / |Net Income|",+ limitations=["Temporal method creates income statement volatility"]+ ))++ # Functional Currency Assessment+ if functional_currencies:+ num_functional_currencies = len(functional_currencies)++ functional_currency_interpretation = f"Operations in {num_functional_currencies} functional currencies increases complexity"+ functional_currency_risk = RiskLevel.MODERATE if num_functional_currencies > 5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Functional Currency Complexity",+ value=num_functional_currencies,+ interpretation=functional_currency_interpretation,+ risk_level=functional_currency_risk,+ methodology="Count of functional currencies used by subsidiaries"+ ))++ # Translation Volatility Analysis+ if comparative_data and len(comparative_data) >= 2:+ translation_adjustments = []+ for past_statements in comparative_data:+ past_adjustment = past_statements.equity_statement.get('translation_adjustment', 0)+ translation_adjustments.append(past_adjustment)++ current_adjustment = equity_statement.get('translation_adjustment', 0)+ translation_adjustments.append(current_adjustment)++ if len(translation_adjustments) > 2:+ translation_volatility = np.std(translation_adjustments)+ mean_adjustment = np.mean([abs(x) for x in translation_adjustments])++ if mean_adjustment > 0:+ volatility_ratio = self.safe_divide(translation_volatility, mean_adjustment)++ volatility_interpretation = "High translation volatility" if volatility_ratio > 1.0 else "Moderate translation volatility" if volatility_ratio > 0.5 else "Low translation volatility"+ volatility_risk = RiskLevel.HIGH if volatility_ratio > 1.5 else RiskLevel.MODERATE if volatility_ratio > 0.8 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Translation Volatility",+ value=volatility_ratio,+ interpretation=volatility_interpretation,+ risk_level=volatility_risk,+ methodology="Standard Deviation of Translation Adjustments / Mean Absolute Adjustment"+ ))++ return results++ def _analyze_geographic_segments(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze geographic segment performance and concentration"""+ results = []++ notes = statements.notes++ # Extract geographic segment data+ geographic_segments = self._extract_geographic_segments(notes)++ if not geographic_segments:+ return results++ total_revenue = sum(segment.get('revenue', 0) for segment in geographic_segments.values())+ total_assets = sum(segment.get('assets', 0) for segment in geographic_segments.values())++ # Geographic Concentration Analysis+ if total_revenue > 0:+ revenue_by_region = {region: segment.get('revenue', 0) for region, segment in geographic_segments.items()}+ largest_region_revenue = max(revenue_by_region.values())++ geographic_concentration = self.safe_divide(largest_region_revenue, total_revenue)++ concentration_interpretation = "High geographic concentration risk" if geographic_concentration > 0.6 else "Moderate geographic concentration" if geographic_concentration > 0.4 else "Well-diversified geographic presence"+ concentration_risk = RiskLevel.HIGH if geographic_concentration > 0.7 else RiskLevel.MODERATE if geographic_concentration > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Geographic Revenue Concentration",+ value=geographic_concentration,+ interpretation=concentration_interpretation,+ risk_level=concentration_risk,+ methodology="Largest Region Revenue / Total Revenue"+ ))++ # Emerging vs Developed Markets Analysis+ emerging_markets = ['china', 'india', 'brazil', 'russia', 'mexico', 'turkey', 'south_africa']+ em_revenue = 0+ dm_revenue = 0++ for region, segment in geographic_segments.items():+ region_revenue = segment.get('revenue', 0)+ if any(em in region.lower() for em in emerging_markets):+ em_revenue += region_revenue+ else:+ dm_revenue += region_revenue++ if total_revenue > 0:+ em_exposure = self.safe_divide(em_revenue, total_revenue)+ benchmark = self.currency_benchmarks['emerging_market_exposure']++ if em_exposure > benchmark['very_high']:+ em_interpretation = "Very high emerging market exposure - significant political and economic risk"+ em_risk = RiskLevel.HIGH+ elif em_exposure > benchmark['high']:+ em_interpretation = "High emerging market exposure"+ em_risk = RiskLevel.MODERATE+ elif em_exposure > benchmark['moderate']:+ em_interpretation = "Moderate emerging market exposure"+ em_risk = RiskLevel.MODERATE+ else:+ em_interpretation = "Low emerging market exposure"+ em_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Emerging Market Exposure",+ value=em_exposure,+ interpretation=em_interpretation,+ risk_level=em_risk,+ methodology="Emerging Market Revenue / Total Revenue"+ ))++ # Regional Performance Analysis+ for region, segment in geographic_segments.items():+ region_revenue = segment.get('revenue', 0)+ region_profit = segment.get('profit', 0)++ if region_revenue > 0:+ region_margin = self.safe_divide(region_profit, region_revenue)+ region_contribution = self.safe_divide(region_revenue, total_revenue) if total_revenue > 0 else 0++ if region_contribution > 0.1: # Only analyze significant regions+ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name=f"{region.title()} Regional Margin",+ value=region_margin,+ interpretation=f"{region.title()} margin of {self.format_percentage(region_margin)} ({self.format_percentage(region_contribution)} of total revenue)",+ risk_level=RiskLevel.LOW if region_margin > 0.1 else RiskLevel.MODERATE if region_margin > 0.05 else RiskLevel.HIGH,+ methodology="Regional Profit / Regional Revenue"+ ))++ return results++ def _analyze_hyperinflationary_economies(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze operations in hyperinflationary economies"""+ results = []++ notes = statements.notes++ # Identify hyperinflationary economies+ hyperinflationary_countries = notes.get('hyperinflationary_countries', [])+ hyperinflationary_revenue = notes.get('hyperinflationary_revenue', 0)+ hyperinflationary_assets = notes.get('hyperinflationary_assets', 0)++ total_revenue = statements.income_statement.get('revenue', 0)+ total_assets = statements.balance_sheet.get('total_assets', 0)++ if hyperinflationary_countries:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Hyperinflationary Economy Operations",+ value=len(hyperinflationary_countries),+ interpretation=f"Operations in {len(hyperinflationary_countries)} hyperinflationary economies: {', '.join(hyperinflationary_countries)}",+ risk_level=RiskLevel.HIGH if len(hyperinflationary_countries) > 2 else RiskLevel.MODERATE,+ methodology="Count and identification of hyperinflationary economy operations",+ limitations=["Hyperinflationary accounting requires complex restatement procedures"]+ ))++ # Hyperinflationary Revenue Exposure+ if hyperinflationary_revenue > 0 and total_revenue > 0:+ hyperinflation_revenue_ratio = self.safe_divide(hyperinflationary_revenue, total_revenue)++ hyperinflation_interpretation = "Significant hyperinflationary economy revenue exposure" if hyperinflation_revenue_ratio > 0.2 else "Moderate hyperinflationary exposure" if hyperinflation_revenue_ratio > 0.1 else "Limited hyperinflationary exposure"+ hyperinflation_risk = RiskLevel.HIGH if hyperinflation_revenue_ratio > 0.3 else RiskLevel.MODERATE if hyperinflation_revenue_ratio > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Hyperinflationary Revenue Exposure",+ value=hyperinflation_revenue_ratio,+ interpretation=hyperinflation_interpretation,+ risk_level=hyperinflation_risk,+ methodology="Hyperinflationary Economy Revenue / Total Revenue"+ ))++ # Inflation Adjustment Impact+ inflation_adjustment = notes.get('hyperinflation_adjustment', 0)+ if inflation_adjustment != 0:+ net_income = statements.income_statement.get('net_income', 0)++ if net_income != 0:+ inflation_impact = self.safe_divide(abs(inflation_adjustment), abs(net_income))++ inflation_impact_interpretation = "Significant hyperinflation adjustment impact on earnings" if inflation_impact > 0.2 else "Moderate hyperinflation impact" if inflation_impact > 0.1 else "Limited hyperinflation impact"+ inflation_impact_risk = RiskLevel.HIGH if inflation_impact > 0.3 else RiskLevel.MODERATE if inflation_impact > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Hyperinflation Adjustment Impact",+ value=inflation_impact,+ interpretation=inflation_impact_interpretation,+ risk_level=inflation_impact_risk,+ methodology="|Hyperinflation Adjustment| / |Net Income|"+ ))++ return results++ def _analyze_currency_hedging(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze foreign currency hedging activities"""+ results = []++ notes = statements.notes+ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ # Derivative instruments for hedging+ derivative_assets = balance_sheet.get('derivative_assets', 0)+ derivative_liabilities = balance_sheet.get('derivative_liabilities', 0)++ # Hedging effectiveness+ hedge_ineffectiveness = income_statement.get('hedge_ineffectiveness', 0)++ # Notional amounts of currency derivatives+ fx_derivatives_notional = notes.get('fx_derivatives_notional', 0)+ foreign_exposure_estimate = notes.get('total_foreign_exposure', 0)++ if fx_derivatives_notional > 0:+ # Hedging Ratio Analysis+ if foreign_exposure_estimate > 0:+ hedging_ratio = self.safe_divide(fx_derivatives_notional, foreign_exposure_estimate)++ hedging_interpretation = "High hedging coverage" if hedging_ratio > 0.8 else "Moderate hedging coverage" if hedging_ratio > 0.5 else "Low hedging coverage" if hedging_ratio > 0.2 else "Minimal hedging"+ hedging_risk = RiskLevel.LOW if hedging_ratio > 0.7 else RiskLevel.MODERATE if hedging_ratio > 0.4 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Currency Hedging Ratio",+ value=hedging_ratio,+ interpretation=hedging_interpretation,+ risk_level=hedging_risk,+ methodology="FX Derivatives Notional / Estimated Foreign Exposure",+ limitations=["Hedging effectiveness depends on correlation and timing"]+ ))++ # Hedge Effectiveness Analysis+ if hedge_ineffectiveness != 0:+ net_income = income_statement.get('net_income', 0)++ if net_income != 0:+ ineffectiveness_impact = self.safe_divide(abs(hedge_ineffectiveness), abs(net_income))++ effectiveness_interpretation = "Significant hedge ineffectiveness impacting earnings" if ineffectiveness_impact > 0.05 else "Moderate hedge ineffectiveness" if ineffectiveness_impact > 0.02 else "Good hedge effectiveness"+ effectiveness_risk = RiskLevel.HIGH if ineffectiveness_impact > 0.1 else RiskLevel.MODERATE if ineffectiveness_impact > 0.03 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Hedge Ineffectiveness Impact",+ value=ineffectiveness_impact,+ interpretation=effectiveness_interpretation,+ risk_level=effectiveness_risk,+ methodology="|Hedge Ineffectiveness| / |Net Income|"+ ))++ return results++ def _analyze_ratio_impacts(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze impact of currency fluctuations on financial ratios"""+ results = []++ if not comparative_data or len(comparative_data) == 0:+ return results++ # Calculate key ratios for current and prior periods+ current_ratios = self._calculate_key_ratios(statements)+ prior_ratios = self._calculate_key_ratios(comparative_data[-1])++ # Currency impact assessment+ exchange_rate_changes = statements.notes.get('major_exchange_rate_changes', {})++ if exchange_rate_changes:+ # Analyze ratio stability under currency fluctuations+ for ratio_name, current_value in current_ratios.items():+ prior_value = prior_ratios.get(ratio_name, 0)++ if prior_value != 0:+ ratio_change = (current_value / prior_value) - 1++ # Assess if change is primarily due to currency effects+ if abs(ratio_change) > 0.1: # 10% threshold+ currency_impact_interpretation = f"{ratio_name.replace('_', ' ').title()} changed by {self.format_percentage(ratio_change)} - assess currency impact"+ currency_impact_risk = RiskLevel.MODERATE if abs(ratio_change) > 0.2 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=f"Currency Impact on {ratio_name.replace('_', ' ').title()}",+ value=ratio_change,+ interpretation=currency_impact_interpretation,+ risk_level=currency_impact_risk,+ methodology="Period-over-period ratio change analysis",+ limitations=["Ratio changes may be due to operational factors beyond currency"]+ ))++ return results++ def _analyze_sales_sustainability(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze sustainability of sales growth components"""+ results = []++ if not comparative_data or len(comparative_data) == 0:+ return results++ notes = statements.notes+ income_statement = statements.income_statement++ current_revenue = income_statement.get('revenue', 0)+ prior_revenue = comparative_data[-1].income_statement.get('revenue', 0)++ if prior_revenue > 0:+ total_growth = (current_revenue / prior_revenue) - 1++ # Decompose sales growth+ organic_growth = notes.get('organic_sales_growth', 0)+ fx_impact_on_sales = notes.get('fx_impact_on_sales', 0)+ acquisition_impact = notes.get('acquisition_impact_on_sales', 0)++ # Volume vs Price analysis+ volume_growth = notes.get('volume_growth', 0)+ price_growth = notes.get('price_growth', 0)++ # Analyze growth sustainability+ if organic_growth != 0:+ organic_ratio = self.safe_divide(organic_growth, total_growth) if total_growth != 0 else 0++ sustainability_interpretation = "Sustainable organic growth drives revenue" if organic_ratio > 0.7 else "Mixed growth drivers" if organic_ratio > 0.4 else "Growth heavily dependent on external factors"+ sustainability_risk = RiskLevel.LOW if organic_ratio > 0.6 else RiskLevel.MODERATE if organic_ratio > 0.3 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Organic Growth Sustainability",+ value=organic_ratio,+ interpretation=sustainability_interpretation,+ risk_level=sustainability_risk,+ methodology="Organic Growth / Total Revenue Growth"+ ))++ # FX Impact on Growth+ if fx_impact_on_sales != 0 and total_growth != 0:+ fx_contribution = self.safe_divide(fx_impact_on_sales, total_growth)++ fx_interpretation = f"Currency {'tailwind' if fx_impact_on_sales > 0 else 'headwind'} contributed {self.format_percentage(abs(fx_contribution))} to revenue growth"+ fx_risk = RiskLevel.MODERATE if abs(fx_contribution) > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="FX Impact on Revenue Growth",+ value=fx_contribution,+ interpretation=fx_interpretation,+ risk_level=fx_risk,+ methodology="FX Impact on Sales / Total Revenue Growth"+ ))++ return results++ def _extract_currency_exposures(self, notes: Dict) -> Dict[str, float]:+ """Extract currency exposure data from notes"""+ currency_exposures = {}++ # Look for currency-specific exposures+ for key, value in notes.items():+ if 'currency' in key.lower() and isinstance(value, (int, float)):+ currency_name = key.replace('_currency_exposure', '').replace('_exposure', '')+ currency_exposures[currency_name] = value++ return currency_exposures++ def _extract_geographic_segments(self, notes: Dict) -> Dict[str, Dict[str, float]]:+ """Extract geographic segment data from notes"""+ segments = {}++ # Common geographic regions+ regions = ['north_america', 'europe', 'asia_pacific', 'latin_america', 'middle_east_africa']++ for region in regions:+ segment_data = {}+ for metric in ['revenue', 'profit', 'assets']:+ key = f"{region}_{metric}"+ if key in notes:+ segment_data[metric] = notes[key]++ if segment_data:+ segments[region] = segment_data++ return segments++ def _calculate_key_ratios(self, statements: FinancialStatements) -> Dict[str, float]:+ """Calculate key financial ratios for currency impact analysis"""+ ratios = {}++ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ revenue = income_statement.get('revenue', 0)+ net_income = income_statement.get('net_income', 0)+ total_assets = balance_sheet.get('total_assets', 0)+ total_equity = balance_sheet.get('total_equity', 0)++ if revenue > 0:+ ratios['net_margin'] = self.safe_divide(net_income, revenue)++ if total_assets > 0:+ ratios['asset_turnover'] = self.safe_divide(revenue, total_assets)+ ratios['roa'] = self.safe_divide(net_income, total_assets)++ if total_equity > 0:+ ratios['roe'] = self.safe_divide(net_income, total_equity)++ return ratios++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key multinational operations metrics"""++ notes = statements.notes+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ metrics = {}++ # Foreign exposure ratios+ foreign_revenue = notes.get('foreign_revenue', 0)+ foreign_assets = notes.get('foreign_assets', 0)+ total_revenue = income_statement.get('revenue', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ if total_revenue > 0:+ metrics['foreign_revenue_ratio'] = self.safe_divide(foreign_revenue, total_revenue)++ if total_assets > 0:+ metrics['foreign_asset_ratio'] = self.safe_divide(foreign_assets, total_assets)++ # Translation impact+ translation_adjustment = statements.equity_statement.get('translation_adjustment', 0)+ total_equity = balance_sheet.get('total_equity', 0)++ if total_equity > 0:+ metrics['translation_impact_ratio'] = self.safe_divide(abs(translation_adjustment), total_equity)++ # Hedging metrics+ fx_derivatives_notional = notes.get('fx_derivatives_notional', 0)+ total_foreign_exposure = notes.get('total_foreign_exposure', 0)++ if total_foreign_exposure > 0:+ metrics['hedging_ratio'] = self.safe_divide(fx_derivatives_notional, total_foreign_exposure)++ # Geographic concentration+ geographic_segments = self._extract_geographic_segments(notes)+ if geographic_segments:+ total_segment_revenue = sum(segment.get('revenue', 0) for segment in geographic_segments.values())+ if total_segment_revenue > 0:+ max_segment_revenue = max(segment.get('revenue', 0) for segment in geographic_segments.values())+ metrics['geographic_concentration'] = self.safe_divide(max_segment_revenue, total_segment_revenue)++ return metrics++ def create_currency_exposure_analysis(self, statements: FinancialStatements) -> CurrencyExposureAnalysis:+ """Create comprehensive currency exposure analysis object"""++ notes = statements.notes+ balance_sheet = statements.balance_sheet++ # Extract exposure data+ foreign_revenue = notes.get('foreign_revenue', 0)+ foreign_assets = notes.get('foreign_assets', 0)+ foreign_receivables = balance_sheet.get('foreign_receivables', 0)+ foreign_payables = balance_sheet.get('foreign_payables', 0)++ total_foreign_exposure = foreign_revenue + foreign_assets+ exposure_by_currency = self._extract_currency_exposures(notes)++ # Transaction exposure+ net_transaction_exposure = foreign_receivables - foreign_payables++ # Translation exposure+ net_investment_exposure = foreign_assets+ translation_gains_losses = statements.income_statement.get('foreign_exchange_gains_losses', 0)++ # Risk assessment+ currency_exposures = list(exposure_by_currency.values()) if exposure_by_currency else [total_foreign_exposure]+ max_exposure = max(currency_exposures) if currency_exposures else 0+ total_exposure = sum(currency_exposures) if currency_exposures else total_foreign_exposure++ concentration_ratio = self.safe_divide(max_exposure, total_exposure) if total_exposure > 0 else 0++ if concentration_ratio > 0.7:+ currency_concentration_risk = RiskLevel.HIGH+ elif concentration_ratio > 0.5:+ currency_concentration_risk = RiskLevel.MODERATE+ else:+ currency_concentration_risk = RiskLevel.LOW++ # Hedging effectiveness+ fx_derivatives_notional = notes.get('fx_derivatives_notional', 0)+ hedging_effectiveness = self.safe_divide(fx_derivatives_notional,+ total_foreign_exposure) if total_foreign_exposure > 0 else 0++ return CurrencyExposureAnalysis(+ total_foreign_exposure=total_foreign_exposure,+ exposure_by_currency=exposure_by_currency,+ foreign_receivables=foreign_receivables,+ foreign_payables=foreign_payables,+ net_transaction_exposure=net_transaction_exposure,+ net_investment_exposure=net_investment_exposure,+ translation_gains_losses=translation_gains_losses,+ currency_concentration_risk=currency_concentration_risk,+ hedging_effectiveness=hedging_effectiveness+ )++ def create_geographic_analysis(self, statements: FinancialStatements) -> GeographicSegmentAnalysis:+ """Create comprehensive geographic segment analysis object"""++ notes = statements.notes++ segments_by_region = self._extract_geographic_segments(notes)++ # Extract performance metrics by region+ revenue_by_region = {}+ profit_by_region = {}+ assets_by_region = {}++ for region, segment in segments_by_region.items():+ revenue_by_region[region] = segment.get('revenue', 0)+ profit_by_region[region] = segment.get('profit', 0)+ assets_by_region[region] = segment.get('assets', 0)++ # Calculate concentration metrics+ total_revenue = sum(revenue_by_region.values())+ max_region_revenue = max(revenue_by_region.values()) if revenue_by_region else 0++ geographic_concentration = self.safe_divide(max_region_revenue, total_revenue) if total_revenue > 0 else 0+ top_region_dependency = geographic_concentration++ # Emerging vs developed markets+ emerging_markets = ['china', 'india', 'brazil', 'russia', 'mexico', 'turkey', 'south_africa']+ emerging_revenue = 0+ developed_revenue = 0++ for region, revenue in revenue_by_region.items():+ if any(em in region.lower() for em in emerging_markets):+ emerging_revenue += revenue+ else:+ developed_revenue += revenue++ emerging_markets_exposure = self.safe_divide(emerging_revenue, total_revenue) if total_revenue > 0 else 0+ developed_markets_exposure = self.safe_divide(developed_revenue, total_revenue) if total_revenue > 0 else 0++ return GeographicSegmentAnalysis(+ segments_by_region=segments_by_region,+ revenue_by_region=revenue_by_region,+ profit_by_region=profit_by_region,+ assets_by_region=assets_by_region,+ geographic_concentration=geographic_concentration,+ top_region_dependency=top_region_dependency,+ emerging_markets_exposure=emerging_markets_exposure,+ developed_markets_exposure=developed_markets_exposure+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/quality_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/quality_analysis.pynew file mode 100644index 000000000..0b3fdc088--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/quality_analysis.py@@ -0,0 +1,31 @@++"""+Financial Statement Quality Analysis Module+========================================++Earnings quality and financial sustainability analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/tax_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/tax_analysis.pynew file mode 100644index 000000000..44e898823--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/tax_analysis.py@@ -0,0 +1,992 @@++"""+Financial Statement Tax Analysis Module+========================================++Tax analysis and optimization strategies++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class TaxDifferenceType(Enum):+ """Types of tax differences"""+ TEMPORARY = "temporary"+ PERMANENT = "permanent"+++class DeferredTaxType(Enum):+ """Types of deferred tax items"""+ ASSET = "deferred_tax_asset"+ LIABILITY = "deferred_tax_liability"+++class TaxStrategy(Enum):+ """Tax strategy classification"""+ AGGRESSIVE = "aggressive"+ MODERATE = "moderate"+ CONSERVATIVE = "conservative"+++@dataclass+class TaxRateAnalysis:+ """Comprehensive tax rate analysis"""+ statutory_tax_rate: float+ effective_tax_rate: float+ cash_tax_rate: float++ # Rate comparisons+ etr_vs_statutory: float+ cash_vs_effective: float++ # Tax efficiency metrics+ tax_efficiency_score: float+ rate_volatility: float = None++ # Explanatory factors+ rate_reconciliation: Dict[str, float] = field(default_factory=dict)+ permanent_differences: List[str] = field(default_factory=list)+++@dataclass+class DeferredTaxAnalysis:+ """Deferred tax assets and liabilities analysis"""+ deferred_tax_assets: float+ deferred_tax_liabilities: float+ net_deferred_tax_position: float+++ # Quality metrics+ valuation_allowance: float+ dta_realization_probability: float++ # Trend analysis+ net_position_trend: TrendDirection = TrendDirection.STABLE+ reversal_timeline: str = ""+++@dataclass+class TaxPlanningAnalysis:+ """Tax planning and strategy analysis"""+ tax_strategy_classification: TaxStrategy++ # Planning indicators+ tax_optimization_score: float+ international_planning: bool+++ # Risk assessment+ tax_audit_risk: RiskLevel+ compliance_quality: float+ uncertain_tax_positions: float = 0.0+++class TaxAnalyzer(BaseAnalyzer):+ """+ Comprehensive income tax analyzer implementing CFA Institute standards.+ Covers tax rates, deferred taxes, and tax planning assessment.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_tax_formulas()+ self._initialize_tax_benchmarks()++ def _initialize_tax_formulas(self):+ """Initialize tax-specific formulas"""+ self.formula_registry.update({+ 'effective_tax_rate': lambda tax_expense, pretax_income: self.safe_divide(tax_expense, pretax_income),+ 'cash_tax_rate': lambda cash_taxes_paid, pretax_income: self.safe_divide(cash_taxes_paid, pretax_income),+ 'deferred_tax_ratio': lambda deferred_tax_expense, total_tax_expense: self.safe_divide(deferred_tax_expense,+ total_tax_expense),+ 'dta_to_assets': lambda dta, total_assets: self.safe_divide(dta, total_assets),+ 'dtl_to_assets': lambda dtl, total_assets: self.safe_divide(dtl, total_assets),+ 'valuation_allowance_ratio': lambda allowance, gross_dta: self.safe_divide(allowance, gross_dta),+ 'tax_shield_value': lambda interest_expense, tax_rate: interest_expense * tax_rate+ })++ def _initialize_tax_benchmarks(self):+ """Initialize tax-specific benchmarks"""+ # Typical tax rate ranges (country-dependent)+ self.tax_benchmarks = {+ 'effective_tax_rate': {+ 'us_corporate': {'low': 0.15, 'normal': 0.21, 'high': 0.35},+ 'international': {'low': 0.10, 'normal': 0.25, 'high': 0.40},+ 'general': {'low': 0.15, 'normal': 0.25, 'high': 0.35}+ },+ 'etr_volatility': {'low': 0.05, 'moderate': 0.15, 'high': 0.30},+ 'cash_vs_book_difference': {'minimal': 0.05, 'moderate': 0.15, 'significant': 0.30},+ 'deferred_tax_ratio': {'low': 0.1, 'moderate': 0.3, 'high': 0.6}+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive income tax analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all tax aspects+ """+ results = []++ # Check if tax analysis is applicable+ pretax_income = statements.income_statement.get('pretax_income', 0)+ tax_expense = statements.income_statement.get('tax_expense', 0)++ if pretax_income == 0 and tax_expense == 0:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Analysis",+ value=0.0,+ interpretation="No taxable income or tax expense - tax analysis limited",+ risk_level=RiskLevel.LOW,+ methodology="Income statement tax examination"+ ))+ return results++ # Tax rate analysis+ results.extend(self._analyze_tax_rates(statements, comparative_data, industry_data))++ # Deferred tax analysis+ results.extend(self._analyze_deferred_taxes(statements, comparative_data))++ # Tax reconciliation analysis+ results.extend(self._analyze_tax_reconciliation(statements))++ # Cash vs book tax analysis+ results.extend(self._analyze_cash_vs_book_taxes(statements, comparative_data))++ # Tax planning and strategy assessment+ results.extend(self._assess_tax_planning(statements, comparative_data))++ # International tax considerations+ results.extend(self._analyze_international_taxes(statements))++ return results++ def _analyze_tax_rates(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze various tax rates and their implications"""+ results = []++ income_statement = statements.income_statement+ cash_flow = statements.cash_flow+ notes = statements.notes++ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)+ cash_taxes_paid = cash_flow.get('cash_taxes_paid', 0)++ # Effective Tax Rate+ if pretax_income != 0:+ effective_tax_rate = self.safe_divide(tax_expense, pretax_income)++ # Get statutory rate for comparison+ statutory_rate = notes.get('statutory_tax_rate', 0.25) # Default assumption+ country = statements.company_info.country.lower()++ # Country-specific statutory rates (simplified)+ if 'us' in country or 'united states' in country:+ statutory_rate = 0.21+ elif 'uk' in country or 'britain' in country:+ statutory_rate = 0.19+ elif any(eu_country in country for eu_country in ['germany', 'france', 'italy']):+ statutory_rate = 0.30++ etr_vs_statutory = effective_tax_rate - statutory_rate++ # Interpret effective tax rate+ if abs(etr_vs_statutory) < 0.05:+ etr_interpretation = f"Effective tax rate of {self.format_percentage(effective_tax_rate)} aligns with statutory rate"+ etr_risk = RiskLevel.LOW+ elif etr_vs_statutory < -0.10:+ etr_interpretation = f"Low effective tax rate of {self.format_percentage(effective_tax_rate)} indicates tax optimization strategies"+ etr_risk = RiskLevel.MODERATE+ elif etr_vs_statutory > 0.10:+ etr_interpretation = f"High effective tax rate of {self.format_percentage(effective_tax_rate)} above statutory rate"+ etr_risk = RiskLevel.MODERATE+ else:+ etr_interpretation = f"Effective tax rate of {self.format_percentage(effective_tax_rate)} shows moderate variance from statutory"+ etr_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Effective Tax Rate",+ value=effective_tax_rate,+ interpretation=etr_interpretation,+ risk_level=etr_risk,+ benchmark_comparison=self.compare_to_industry(effective_tax_rate, industry_data.get(+ 'effective_tax_rate') if industry_data else None),+ methodology="Income Tax Expense / Pretax Income",+ limitations=["Single period rate may not reflect ongoing tax burden"]+ ))++ # Cash Tax Rate+ if pretax_income != 0 and cash_taxes_paid > 0:+ cash_tax_rate = self.safe_divide(cash_taxes_paid, pretax_income)++ cash_vs_book_difference = abs(cash_tax_rate - effective_tax_rate) if 'effective_tax_rate' in locals() else 0++ if cash_vs_book_difference < 0.05:+ cash_interpretation = "Cash and book tax rates are closely aligned"+ cash_risk = RiskLevel.LOW+ elif cash_vs_book_difference < 0.15:+ cash_interpretation = "Moderate difference between cash and book tax rates"+ cash_risk = RiskLevel.LOW+ else:+ cash_interpretation = "Significant difference between cash and book tax rates - indicates timing differences"+ cash_risk = RiskLevel.MODERATE++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Cash Tax Rate",+ value=cash_tax_rate,+ interpretation=cash_interpretation,+ risk_level=cash_risk,+ methodology="Cash Taxes Paid / Pretax Income",+ limitations=["Cash taxes may include payments for prior years or be affected by timing"]+ ))++ # Tax Rate Volatility Analysis+ if comparative_data and len(comparative_data) >= 2:+ etr_values = []+ periods = []++ for i, past_statements in enumerate(comparative_data):+ past_pretax = past_statements.income_statement.get('pretax_income', 0)+ past_tax = past_statements.income_statement.get('tax_expense', 0)+ if past_pretax != 0:+ past_etr = self.safe_divide(past_tax, past_pretax)+ etr_values.append(past_etr)+ periods.append(f"Period-{len(comparative_data) - i}")++ if 'effective_tax_rate' in locals():+ etr_values.append(effective_tax_rate)+ periods.append("Current")++ if len(etr_values) > 1:+ etr_volatility = np.std(etr_values)++ volatility_interpretation = "High tax rate volatility - inconsistent tax planning" if etr_volatility > 0.15 else "Moderate tax rate variation" if etr_volatility > 0.05 else "Stable effective tax rate"+ volatility_risk = RiskLevel.HIGH if etr_volatility > 0.20 else RiskLevel.MODERATE if etr_volatility > 0.10 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Rate Volatility",+ value=etr_volatility,+ interpretation=volatility_interpretation,+ risk_level=volatility_risk,+ methodology="Standard deviation of effective tax rates over time"+ ))++ return results++ def _analyze_deferred_taxes(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze deferred tax assets and liabilities"""+ results = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement+ notes = statements.notes++ deferred_tax_assets = balance_sheet.get('deferred_tax_asset', 0)+ deferred_tax_liabilities = balance_sheet.get('deferred_tax_liability', 0)+ deferred_tax_expense = income_statement.get('deferred_tax', 0)+ total_tax_expense = income_statement.get('tax_expense', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ # Net Deferred Tax Position+ net_deferred_position = deferred_tax_assets - deferred_tax_liabilities++ if abs(net_deferred_position) > 0:+ net_position_interpretation = f"Net deferred tax {'asset' if net_deferred_position > 0 else 'liability'} of ${abs(net_deferred_position):,.0f}"++ # Assess significance+ if total_assets > 0:+ net_position_ratio = abs(net_deferred_position) / total_assets+ if net_position_ratio > 0.05:+ net_position_interpretation += " - significant deferred tax position"+ position_risk = RiskLevel.MODERATE+ else:+ net_position_interpretation += " - modest deferred tax position"+ position_risk = RiskLevel.LOW+ else:+ position_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Net Deferred Tax Position",+ value=net_deferred_position,+ interpretation=net_position_interpretation,+ risk_level=position_risk,+ methodology="Deferred Tax Assets - Deferred Tax Liabilities"+ ))++ # Deferred Tax Assets Analysis+ if deferred_tax_assets > 0:+ valuation_allowance = notes.get('dta_valuation_allowance', 0)++ if total_assets > 0:+ dta_ratio = self.safe_divide(deferred_tax_assets, total_assets)++ dta_interpretation = "Significant deferred tax assets requiring realization assessment" if dta_ratio > 0.10 else "Moderate deferred tax assets" if dta_ratio > 0.05 else "Limited deferred tax assets"+ dta_risk = RiskLevel.MODERATE if dta_ratio > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="DTA to Total Assets",+ value=dta_ratio,+ interpretation=dta_interpretation,+ risk_level=dta_risk,+ methodology="Deferred Tax Assets / Total Assets",+ limitations=["DTA realization depends on future taxable income"]+ ))++ # Valuation Allowance Analysis+ if valuation_allowance > 0:+ allowance_ratio = self.safe_divide(valuation_allowance, deferred_tax_assets + valuation_allowance)++ allowance_interpretation = "High valuation allowance indicates uncertainty about DTA realization" if allowance_ratio > 0.5 else "Moderate valuation allowance" if allowance_ratio > 0.2 else "Low valuation allowance suggests confident DTA realization"+ allowance_risk = RiskLevel.HIGH if allowance_ratio > 0.6 else RiskLevel.MODERATE if allowance_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="DTA Valuation Allowance Ratio",+ value=allowance_ratio,+ interpretation=allowance_interpretation,+ risk_level=allowance_risk,+ methodology="Valuation Allowance / (DTA + Valuation Allowance)",+ limitations=["High allowance may indicate poor earnings prospects"]+ ))++ # Deferred Tax Liabilities Analysis+ if deferred_tax_liabilities > 0 and total_assets > 0:+ dtl_ratio = self.safe_divide(deferred_tax_liabilities, total_assets)++ dtl_interpretation = "Significant deferred tax liabilities from temporary differences" if dtl_ratio > 0.10 else "Moderate deferred tax liabilities" if dtl_ratio > 0.05 else "Limited deferred tax liabilities"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="DTL to Total Assets",+ value=dtl_ratio,+ interpretation=dtl_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Deferred Tax Liabilities / Total Assets",+ limitations=["DTL reversal timing depends on asset usage and accounting methods"]+ ))++ # Deferred Tax Expense Analysis+ if total_tax_expense != 0 and abs(deferred_tax_expense) > 0:+ deferred_ratio = self.safe_divide(abs(deferred_tax_expense), abs(total_tax_expense))++ deferred_interpretation = "Significant deferred tax component in total tax expense" if deferred_ratio > 0.3 else "Moderate deferred tax impact" if deferred_ratio > 0.15 else "Limited deferred tax expense component"+ deferred_risk = RiskLevel.MODERATE if deferred_ratio > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Deferred Tax Expense Ratio",+ value=deferred_ratio,+ interpretation=deferred_interpretation,+ risk_level=deferred_risk,+ methodology="|Deferred Tax Expense| / |Total Tax Expense|"+ ))++ return results++ def _analyze_tax_reconciliation(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Analyze tax rate reconciliation and permanent differences"""+ results = []++ income_statement = statements.income_statement+ notes = statements.notes++ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)++ if pretax_income == 0:+ return results++ # Look for tax reconciliation items in notes+ reconciliation_items = {+ 'statutory_rate_effect': notes.get('statutory_rate_effect', 0),+ 'permanent_differences': notes.get('permanent_differences', 0),+ 'tax_credits': notes.get('tax_credits', 0),+ 'foreign_rate_differences': notes.get('foreign_rate_differences', 0),+ 'prior_year_adjustments': notes.get('prior_year_tax_adjustments', 0),+ 'other_tax_effects': notes.get('other_tax_effects', 0)+ }++ total_reconciling_items = sum(abs(value) for value in reconciliation_items.values() if value != 0)++ if total_reconciling_items > 0:+ # Analyze significant reconciling items+ for item_name, item_value in reconciliation_items.items():+ if abs(item_value) > abs(tax_expense) * 0.05: # 5% threshold+ item_display_name = item_name.replace('_', ' ').title()+ item_impact = self.safe_divide(item_value, tax_expense) if tax_expense != 0 else 0++ item_interpretation = f"{item_display_name} {'increases' if item_value > 0 else 'decreases'} tax expense by {self.format_percentage(abs(item_impact))}"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=f"Tax Reconciliation - {item_display_name}",+ value=item_impact,+ interpretation=item_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Reconciliation item impact on total tax expense"+ ))++ # Overall reconciliation quality+ effective_tax_rate = self.safe_divide(tax_expense, pretax_income)+ statutory_rate = notes.get('statutory_tax_rate', 0.25)++ reconciliation_explained = self.safe_divide(total_reconciling_items,+ abs(effective_tax_rate - statutory_rate) * abs(+ pretax_income)) if abs(+ effective_tax_rate - statutory_rate) * abs(pretax_income) > 0 else 0++ if reconciliation_explained > 0.8:+ reconciliation_quality = "Comprehensive tax rate reconciliation provided"+ reconciliation_risk = RiskLevel.LOW+ elif reconciliation_explained > 0.5:+ reconciliation_quality = "Adequate tax rate reconciliation"+ reconciliation_risk = RiskLevel.LOW+ else:+ reconciliation_quality = "Limited tax rate reconciliation disclosure"+ reconciliation_risk = RiskLevel.MODERATE++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Reconciliation Quality",+ value=reconciliation_explained,+ interpretation=reconciliation_quality,+ risk_level=reconciliation_risk,+ methodology="Assessment of tax rate reconciliation completeness"+ ))++ return results++ def _analyze_cash_vs_book_taxes(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze differences between cash and book tax amounts"""+ results = []++ income_statement = statements.income_statement+ cash_flow = statements.cash_flow++ tax_expense = income_statement.get('tax_expense', 0)+ cash_taxes_paid = cash_flow.get('cash_taxes_paid', 0)+ current_tax_expense = income_statement.get('current_tax_expense',+ tax_expense) # Fallback to total if not separated+ deferred_tax_expense = income_statement.get('deferred_tax', 0)++ # Cash vs Current Tax Expense+ if current_tax_expense != 0 and cash_taxes_paid > 0:+ cash_vs_current = cash_taxes_paid - current_tax_expense+ cash_timing_ratio = self.safe_divide(abs(cash_vs_current), abs(current_tax_expense))++ if abs(cash_vs_current) < abs(current_tax_expense) * 0.1:+ timing_interpretation = "Cash and current tax expense are closely aligned"+ timing_risk = RiskLevel.LOW+ elif cash_vs_current > 0:+ timing_interpretation = f"Cash taxes exceed current expense by {self.format_percentage(cash_timing_ratio)} - paying for prior years or prepaying"+ timing_risk = RiskLevel.LOW+ else:+ timing_interpretation = f"Current tax expense exceeds cash payments by {self.format_percentage(cash_timing_ratio)} - timing differences or accruals"+ timing_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Cash vs Current Tax Timing",+ value=cash_timing_ratio,+ interpretation=timing_interpretation,+ risk_level=timing_risk,+ methodology="(Cash Taxes Paid - Current Tax Expense) / Current Tax Expense"+ ))++ # Tax Cash Flow Quality+ if comparative_data and len(comparative_data) >= 2:+ cash_tax_values = []+ book_tax_values = []++ for past_statements in comparative_data:+ past_cash_tax = past_statements.cash_flow.get('cash_taxes_paid', 0)+ past_book_tax = past_statements.income_statement.get('tax_expense', 0)+ if past_cash_tax > 0 and past_book_tax != 0:+ cash_tax_values.append(past_cash_tax)+ book_tax_values.append(past_book_tax)++ if cash_taxes_paid > 0 and tax_expense != 0:+ cash_tax_values.append(cash_taxes_paid)+ book_tax_values.append(tax_expense)++ if len(cash_tax_values) > 1 and len(book_tax_values) > 1:+ # Calculate correlation between cash and book taxes+ correlation = np.corrcoef(cash_tax_values, book_tax_values)[0, 1] if len(cash_tax_values) == len(+ book_tax_values) else 0++ correlation_interpretation = "Strong correlation between cash and book taxes" if correlation > 0.8 else "Moderate correlation" if correlation > 0.5 else "Weak correlation - significant timing differences"+ correlation_risk = RiskLevel.LOW if correlation > 0.7 else RiskLevel.MODERATE if correlation > 0.4 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Cash-Book Tax Correlation",+ value=correlation,+ interpretation=correlation_interpretation,+ risk_level=correlation_risk,+ methodology="Correlation coefficient between cash and book tax amounts over time"+ ))++ return results++ def _assess_tax_planning(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Assess tax planning effectiveness and strategy"""+ results = []++ income_statement = statements.income_statement+ notes = statements.notes++ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)++ if pretax_income == 0:+ return results++ effective_tax_rate = self.safe_divide(tax_expense, pretax_income)+ statutory_rate = notes.get('statutory_tax_rate', 0.25)++ # Tax Efficiency Assessment+ tax_savings = (statutory_rate - effective_tax_rate) * pretax_income if pretax_income > 0 else 0+ tax_efficiency_ratio = self.safe_divide(tax_savings,+ abs(pretax_income * statutory_rate)) if statutory_rate > 0 else 0++ if tax_efficiency_ratio > 0.2:+ efficiency_interpretation = "High tax efficiency - significant tax optimization achieved"+ efficiency_risk = RiskLevel.MODERATE # Could indicate aggressive strategies+ strategy_classification = TaxStrategy.AGGRESSIVE+ elif tax_efficiency_ratio > 0.05:+ efficiency_interpretation = "Moderate tax efficiency - some optimization strategies employed"+ efficiency_risk = RiskLevel.LOW+ strategy_classification = TaxStrategy.MODERATE+ elif tax_efficiency_ratio > -0.05:+ efficiency_interpretation = "Standard tax efficiency - limited optimization"+ efficiency_risk = RiskLevel.LOW+ strategy_classification = TaxStrategy.CONSERVATIVE+ else:+ efficiency_interpretation = "Below-average tax efficiency - potential for improvement"+ efficiency_risk = RiskLevel.MODERATE+ strategy_classification = TaxStrategy.CONSERVATIVE++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Planning Efficiency",+ value=tax_efficiency_ratio,+ interpretation=efficiency_interpretation,+ risk_level=efficiency_risk,+ methodology="(Statutory Rate - Effective Rate) × Pretax Income / (Statutory Rate × Pretax Income)"+ ))++ # Uncertain Tax Positions+ uncertain_tax_positions = notes.get('uncertain_tax_positions', 0)+ if uncertain_tax_positions > 0:+ utp_ratio = self.safe_divide(uncertain_tax_positions, abs(tax_expense)) if tax_expense != 0 else 0++ utp_interpretation = "Significant uncertain tax positions indicate aggressive tax strategies" if utp_ratio > 0.5 else "Moderate uncertain tax positions" if utp_ratio > 0.2 else "Limited uncertain tax positions"+ utp_risk = RiskLevel.HIGH if utp_ratio > 0.8 else RiskLevel.MODERATE if utp_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Uncertain Tax Positions",+ value=utp_ratio,+ interpretation=utp_interpretation,+ risk_level=utp_risk,+ methodology="Uncertain Tax Positions / Total Tax Expense",+ limitations=["High UTP may indicate potential tax adjustments"]+ ))++ # Tax Strategy Consistency+ if comparative_data and len(comparative_data) >= 2:+ etr_values = []+ for past_statements in comparative_data:+ past_pretax = past_statements.income_statement.get('pretax_income', 0)+ past_tax = past_statements.income_statement.get('tax_expense', 0)+ if past_pretax != 0:+ past_etr = self.safe_divide(past_tax, past_pretax)+ etr_values.append(past_etr)++ etr_values.append(effective_tax_rate)++ if len(etr_values) > 1:+ etr_consistency = 1 - (np.std(etr_values) / np.mean(etr_values)) if np.mean(etr_values) > 0 else 0++ consistency_interpretation = "Highly consistent tax strategy" if etr_consistency > 0.8 else "Moderately consistent tax approach" if etr_consistency > 0.6 else "Inconsistent tax strategy - may indicate changing circumstances or aggressive planning"+ consistency_risk = RiskLevel.LOW if etr_consistency > 0.7 else RiskLevel.MODERATE if etr_consistency > 0.5 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Tax Strategy Consistency",+ value=etr_consistency,+ interpretation=consistency_interpretation,+ risk_level=consistency_risk,+ methodology="1 - (Standard Deviation of ETR / Mean ETR)"+ ))++ return results++ def _analyze_international_taxes(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Analyze international tax considerations"""+ results = []++ notes = statements.notes+ income_statement = statements.income_statement++ # Foreign tax considerations+ foreign_tax_credit = notes.get('foreign_tax_credit', 0)+ foreign_income = notes.get('foreign_pretax_income', 0)+ domestic_income = notes.get('domestic_pretax_income', 0)++ total_pretax = income_statement.get('pretax_income', 0)++ # Geographic income analysis+ if foreign_income > 0 and total_pretax > 0:+ foreign_income_ratio = self.safe_divide(foreign_income, total_pretax)++ geographic_interpretation = "Significant international operations" if foreign_income_ratio > 0.3 else "Moderate international presence" if foreign_income_ratio > 0.1 else "Primarily domestic operations"+ geographic_risk = RiskLevel.MODERATE if foreign_income_ratio > 0.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="International Income Exposure",+ value=foreign_income_ratio,+ interpretation=geographic_interpretation,+ risk_level=geographic_risk,+ methodology="Foreign Pretax Income / Total Pretax Income",+ limitations=["International operations create additional tax complexity"]+ ))++ # Foreign tax credit utilization+ if foreign_tax_credit > 0:+ total_tax_expense = income_statement.get('tax_expense', 0)+ ftc_ratio = self.safe_divide(foreign_tax_credit, abs(total_tax_expense)) if total_tax_expense != 0 else 0++ ftc_interpretation = "Significant foreign tax credit utilization" if ftc_ratio > 0.2 else "Moderate foreign tax credits" if ftc_ratio > 0.1 else "Limited foreign tax credit usage"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Foreign Tax Credit Utilization",+ value=ftc_ratio,+ interpretation=ftc_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Foreign Tax Credits / Total Tax Expense"+ ))++ # Transfer pricing considerations+ related_party_transactions = notes.get('related_party_revenue', 0) + notes.get('related_party_expenses', 0)+ revenue = income_statement.get('revenue', 0)++ if related_party_transactions > 0 and revenue > 0:+ transfer_pricing_exposure = self.safe_divide(related_party_transactions, revenue)++ tp_interpretation = "High transfer pricing exposure - significant related party transactions" if transfer_pricing_exposure > 0.3 else "Moderate transfer pricing considerations" if transfer_pricing_exposure > 0.1 else "Limited transfer pricing exposure"+ tp_risk = RiskLevel.HIGH if transfer_pricing_exposure > 0.5 else RiskLevel.MODERATE if transfer_pricing_exposure > 0.2 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Transfer Pricing Exposure",+ value=transfer_pricing_exposure,+ interpretation=tp_interpretation,+ risk_level=tp_risk,+ methodology="Related Party Transactions / Revenue",+ limitations=["High exposure increases tax audit and adjustment risk"]+ ))++ return results++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key tax metrics"""++ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet+ cash_flow = statements.cash_flow++ metrics = {}++ # Core tax metrics+ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)+ cash_taxes_paid = cash_flow.get('cash_taxes_paid', 0)++ if pretax_income != 0:+ metrics['effective_tax_rate'] = self.safe_divide(tax_expense, pretax_income)++ if cash_taxes_paid > 0:+ metrics['cash_tax_rate'] = self.safe_divide(cash_taxes_paid, pretax_income)++ # Deferred tax metrics+ deferred_tax_assets = balance_sheet.get('deferred_tax_asset', 0)+ deferred_tax_liabilities = balance_sheet.get('deferred_tax_liability', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ metrics['net_deferred_tax_position'] = deferred_tax_assets - deferred_tax_liabilities++ if total_assets > 0:+ metrics['dta_to_assets'] = self.safe_divide(deferred_tax_assets, total_assets)+ metrics['dtl_to_assets'] = self.safe_divide(deferred_tax_liabilities, total_assets)++ # Tax expense components+ current_tax_expense = income_statement.get('current_tax_expense', 0)+ deferred_tax_expense = income_statement.get('deferred_tax', 0)++ if tax_expense != 0:+ metrics['current_tax_ratio'] = self.safe_divide(current_tax_expense, tax_expense)+ metrics['deferred_tax_ratio'] = self.safe_divide(deferred_tax_expense, tax_expense)++ return metrics++ def create_tax_rate_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> TaxRateAnalysis:+ """Create comprehensive tax rate analysis object"""++ income_statement = statements.income_statement+ cash_flow = statements.cash_flow+ notes = statements.notes++ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)+ cash_taxes_paid = cash_flow.get('cash_taxes_paid', 0)++ # Calculate tax rates+ effective_tax_rate = self.safe_divide(tax_expense, pretax_income) if pretax_income != 0 else 0+ cash_tax_rate = self.safe_divide(cash_taxes_paid,+ pretax_income) if pretax_income != 0 and cash_taxes_paid > 0 else 0+ statutory_tax_rate = notes.get('statutory_tax_rate', 0.25)++ # Rate comparisons+ etr_vs_statutory = effective_tax_rate - statutory_tax_rate+ cash_vs_effective = cash_tax_rate - effective_tax_rate++ # Tax efficiency calculation+ if statutory_tax_rate > 0 and pretax_income > 0:+ tax_savings = (statutory_tax_rate - effective_tax_rate) * pretax_income+ potential_tax = statutory_tax_rate * pretax_income+ tax_efficiency_score = self.safe_divide(tax_savings, abs(potential_tax)) * 100+ else:+ tax_efficiency_score = 0++ # Rate volatility+ rate_volatility = None+ if comparative_data and len(comparative_data) >= 2:+ etr_values = []+ for past_statements in comparative_data:+ past_pretax = past_statements.income_statement.get('pretax_income', 0)+ past_tax = past_statements.income_statement.get('tax_expense', 0)+ if past_pretax != 0:+ past_etr = self.safe_divide(past_tax, past_pretax)+ etr_values.append(past_etr)++ etr_values.append(effective_tax_rate)+ if len(etr_values) > 1:+ rate_volatility = np.std(etr_values)++ # Rate reconciliation+ rate_reconciliation = {+ 'statutory_rate_effect': notes.get('statutory_rate_effect', 0),+ 'permanent_differences': notes.get('permanent_differences', 0),+ 'tax_credits': notes.get('tax_credits', 0),+ 'foreign_rate_differences': notes.get('foreign_rate_differences', 0)+ }++ # Permanent differences identification+ permanent_differences = []+ if notes.get('municipal_bond_interest', 0) > 0:+ permanent_differences.append("Tax-exempt interest income")+ if notes.get('meals_entertainment', 0) > 0:+ permanent_differences.append("Non-deductible meals and entertainment")+ if notes.get('life_insurance_proceeds', 0) > 0:+ permanent_differences.append("Life insurance proceeds")++ return TaxRateAnalysis(+ statutory_tax_rate=statutory_tax_rate,+ effective_tax_rate=effective_tax_rate,+ cash_tax_rate=cash_tax_rate,+ etr_vs_statutory=etr_vs_statutory,+ cash_vs_effective=cash_vs_effective,+ tax_efficiency_score=tax_efficiency_score,+ rate_volatility=rate_volatility,+ rate_reconciliation=rate_reconciliation,+ permanent_differences=permanent_differences+ )++ def create_deferred_tax_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> DeferredTaxAnalysis:+ """Create comprehensive deferred tax analysis object"""++ balance_sheet = statements.balance_sheet+ notes = statements.notes++ deferred_tax_assets = balance_sheet.get('deferred_tax_asset', 0)+ deferred_tax_liabilities = balance_sheet.get('deferred_tax_liability', 0)+ net_deferred_tax_position = deferred_tax_assets - deferred_tax_liabilities++ # Composition analysis+ dta_composition = {+ 'nol_carryforwards': notes.get('nol_dta', 0),+ 'depreciation_differences': notes.get('depreciation_dta', 0),+ 'accrued_expenses': notes.get('accrual_dta', 0),+ 'other': notes.get('other_dta', 0)+ }++ dtl_composition = {+ 'depreciation_differences': notes.get('depreciation_dtl', 0),+ 'intangible_amortization': notes.get('intangible_dtl', 0),+ 'other': notes.get('other_dtl', 0)+ }++ # Valuation allowance and realization+ valuation_allowance = notes.get('dta_valuation_allowance', 0)+ gross_dta = deferred_tax_assets + valuation_allowance+ dta_realization_probability = self.safe_divide(deferred_tax_assets, gross_dta) if gross_dta > 0 else 1.0++ # Trend analysis+ net_position_trend = TrendDirection.STABLE+ if comparative_data and len(comparative_data) >= 2:+ net_position_values = []+ for past_statements in comparative_data:+ past_dta = past_statements.balance_sheet.get('deferred_tax_asset', 0)+ past_dtl = past_statements.balance_sheet.get('deferred_tax_liability', 0)+ net_position_values.append(past_dta - past_dtl)++ net_position_values.append(net_deferred_tax_position)++ if len(net_position_values) >= 3:+ if net_position_values[-1] > net_position_values[0] * 1.1:+ net_position_trend = TrendDirection.IMPROVING+ elif net_position_values[-1] < net_position_values[0] * 0.9:+ net_position_trend = TrendDirection.DETERIORATING++ # Reversal timeline assessment+ reversal_timeline = "Long-term reversal expected" if abs(+ net_deferred_tax_position) > 0 else "No significant deferred taxes"++ return DeferredTaxAnalysis(+ deferred_tax_assets=deferred_tax_assets,+ deferred_tax_liabilities=deferred_tax_liabilities,+ net_deferred_tax_position=net_deferred_tax_position,+ dta_composition=dta_composition,+ dtl_composition=dtl_composition,+ valuation_allowance=valuation_allowance,+ dta_realization_probability=dta_realization_probability,+ net_position_trend=net_position_trend,+ reversal_timeline=reversal_timeline+ )++ def assess_tax_planning_strategy(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> TaxPlanningAnalysis:+ """Assess tax planning effectiveness and strategy"""++ income_statement = statements.income_statement+ notes = statements.notes++ pretax_income = income_statement.get('pretax_income', 0)+ tax_expense = income_statement.get('tax_expense', 0)+ effective_tax_rate = self.safe_divide(tax_expense, pretax_income) if pretax_income != 0 else 0+ statutory_rate = notes.get('statutory_tax_rate', 0.25)++ # Strategy classification+ tax_savings_rate = (statutory_rate - effective_tax_rate) / statutory_rate if statutory_rate > 0 else 0++ if tax_savings_rate > 0.25:+ tax_strategy_classification = TaxStrategy.AGGRESSIVE+ elif tax_savings_rate > 0.10:+ tax_strategy_classification = TaxStrategy.MODERATE+ else:+ tax_strategy_classification = TaxStrategy.CONSERVATIVE++ # Tax optimization score+ tax_optimization_score = min(100, max(0, tax_savings_rate * 100))++ # International planning assessment+ foreign_income = notes.get('foreign_pretax_income', 0)+ international_planning = foreign_income > 0++ # Timing strategies identification+ timing_strategies = []+ if notes.get('installment_sales', 0) > 0:+ timing_strategies.append("Installment sale deferrals")+ if notes.get('like_kind_exchanges', 0) > 0:+ timing_strategies.append("Like-kind exchanges")+ if notes.get('depreciation_elections', 0) > 0:+ timing_strategies.append("Accelerated depreciation elections")++ # Risk assessment+ uncertain_tax_positions = notes.get('uncertain_tax_positions', 0)+ if uncertain_tax_positions > abs(tax_expense) * 0.5:+ tax_audit_risk = RiskLevel.HIGH+ elif uncertain_tax_positions > abs(tax_expense) * 0.2:+ tax_audit_risk = RiskLevel.MODERATE+ else:+ tax_audit_risk = RiskLevel.LOW++ # Compliance quality+ compliance_quality = 100+ if notes.get('tax_penalties', 0) > 0:+ compliance_quality -= 20+ if notes.get('prior_year_adjustments', 0) > abs(tax_expense) * 0.1:+ compliance_quality -= 15++ compliance_quality = max(0, compliance_quality)++ return TaxPlanningAnalysis(+ tax_strategy_classification=tax_strategy_classification,+ tax_optimization_score=tax_optimization_score,+ international_planning=international_planning,+ timing_strategies=timing_strategies,+ tax_audit_risk=tax_audit_risk,+ compliance_quality=compliance_quality,+ uncertain_tax_positions=uncertain_tax_positions+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/balance_sheet.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/balance_sheet.pynew file mode 100644index 000000000..4e45e3fd9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/balance_sheet.py@@ -0,0 +1,970 @@++"""+Financial Statement Balance Sheet Module+========================================++Balance sheet analysis and financial position assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class AssetQuality(Enum):+ """Asset quality classification"""+ HIGH_QUALITY = "high_quality"+ MODERATE_QUALITY = "moderate_quality"+ LOW_QUALITY = "low_quality"+ IMPAIRED = "impaired"+++class LiabilityType(Enum):+ """Liability classification"""+ CURRENT = "current"+ NON_CURRENT = "non_current"+ CONTINGENT = "contingent"+ OFF_BALANCE_SHEET = "off_balance_sheet"+++class EquityStructure(Enum):+ """Equity structure classification"""+ SIMPLE = "simple"+ COMPLEX = "complex"+ HIGHLY_LEVERAGED = "highly_leveraged"+++@dataclass+class LiquidityAnalysis:+ """Comprehensive liquidity analysis results"""+ current_ratio: float+ quick_ratio: float+ cash_ratio: float+ working_capital: float+ working_capital_ratio: float+ net_working_capital: float+ liquidity_quality_score: float+ liquidity_risk_level: RiskLevel+ short_term_debt_coverage: float = None+ cash_conversion_cycle: float = None+++@dataclass+class AssetAnalysis:+ """Detailed asset composition and quality analysis"""+ asset_turnover: float+ current_asset_ratio: float+ non_current_asset_ratio: float+ intangible_asset_ratio: float+ goodwill_ratio: float+ ppe_ratio: float+ asset_quality_score: float+ depreciation_rate: float = None+ asset_age_factor: float = None+ impairment_indicators: List[str] = field(default_factory=list)+++@dataclass+class LiabilityAnalysis:+ """Comprehensive liability structure analysis"""+ debt_to_equity: float+ debt_to_assets: float+ current_liability_ratio: float+ long_term_debt_ratio: float+ interest_bearing_debt_ratio: float+ debt_maturity_profile: Dict[str, float] = field(default_factory=dict)+ off_balance_sheet_items: float = None+ contingent_liabilities: float = None+++@dataclass+class EquityAnalysis:+ """Equity structure and quality analysis"""+ equity_ratio: float+ retained_earnings_ratio: float+ book_value_per_share: float+ tangible_book_value_per_share: float+ equity_multiplier: float+ return_on_equity: float = None+ dividend_coverage: float = None+ share_repurchase_activity: float = None+++class BalanceSheetAnalyzer(BaseAnalyzer):+ """+ Comprehensive balance sheet analyzer implementing CFA Institute standards.+ Covers asset analysis, liability evaluation, liquidity assessment, and equity structure.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_balance_sheet_formulas()+ self._initialize_balance_sheet_benchmarks()++ def _initialize_balance_sheet_formulas(self):+ """Initialize balance sheet specific formulas"""+ self.formula_registry.update({+ 'current_ratio': lambda current_assets, current_liabs: self.safe_divide(current_assets, current_liabs),+ 'quick_ratio': lambda quick_assets, current_liabs: self.safe_divide(quick_assets, current_liabs),+ 'cash_ratio': lambda cash, current_liabs: self.safe_divide(cash, current_liabs),+ 'debt_to_equity': lambda total_debt, total_equity: self.safe_divide(total_debt, total_equity),+ 'debt_to_assets': lambda total_debt, total_assets: self.safe_divide(total_debt, total_assets),+ 'asset_turnover': lambda revenue, avg_total_assets: self.safe_divide(revenue, avg_total_assets),+ 'equity_multiplier': lambda total_assets, total_equity: self.safe_divide(total_assets, total_equity),+ 'working_capital_ratio': lambda working_capital, total_assets: self.safe_divide(working_capital,+ total_assets)+ })++ def _initialize_balance_sheet_benchmarks(self):+ """Initialize balance sheet specific benchmarks"""+ # Asset composition benchmarks (industry-dependent)+ self.asset_composition_benchmarks = {+ 'current_asset_ratio': {'high': 0.4, 'moderate': 0.3, 'low': 0.2},+ 'intangible_ratio': {'high': 0.3, 'moderate': 0.15, 'low': 0.05},+ 'goodwill_ratio': {'high': 0.2, 'moderate': 0.1, 'low': 0.05}+ }++ # Liability structure benchmarks+ self.liability_benchmarks = {+ 'current_liability_ratio': {'high': 0.4, 'moderate': 0.3, 'low': 0.2},+ 'long_term_debt_ratio': {'high': 0.4, 'moderate': 0.25, 'low': 0.15}+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive balance sheet analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all balance sheet aspects+ """+ results = []++ # Validate data sufficiency+ required_fields = ['total_assets', 'total_liabilities', 'total_equity']+ is_sufficient, missing_fields = self.validate_data_sufficiency(statements, required_fields)++ if not is_sufficient:+ if self.logger:+ self.logger.warning(f"Insufficient data for complete analysis. Missing: {missing_fields}")++ # Liquidity analysis+ results.extend(self._analyze_liquidity(statements, comparative_data, industry_data))++ # Asset analysis+ results.extend(self._analyze_assets(statements, comparative_data, industry_data))++ # Liability analysis+ results.extend(self._analyze_liabilities(statements, comparative_data, industry_data))++ # Equity analysis+ results.extend(self._analyze_equity(statements, comparative_data, industry_data))++ # Financial position quality+ results.extend(self._assess_financial_position_quality(statements, comparative_data))++ # Common-size analysis+ results.extend(self._perform_common_size_analysis(statements, comparative_data))++ # Balance sheet relationships+ results.extend(self._analyze_balance_sheet_relationships(statements, comparative_data))++ return results++ def _analyze_liquidity(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Comprehensive liquidity analysis"""+ results = []+ balance_sheet = statements.balance_sheet++ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ cash_equivalents = balance_sheet.get('cash_equivalents', 0)+ accounts_receivable = balance_sheet.get('accounts_receivable', 0)+ inventory = balance_sheet.get('inventory', 0)++ # Current Ratio+ if current_liabilities > 0:+ current_ratio = self.safe_divide(current_assets, current_liabilities)+ benchmark = self.liquidity_benchmarks.get('current_ratio', {})+ risk_level = self.assess_risk_level(current_ratio, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.LIQUIDITY,+ metric_name="Current Ratio",+ value=current_ratio,+ interpretation=self.generate_interpretation("current ratio", current_ratio, risk_level,+ AnalysisType.LIQUIDITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(current_ratio, industry_data.get(+ 'current_ratio') if industry_data else None),+ methodology="Current Assets / Current Liabilities",+ limitations=["Does not consider asset quality or conversion timing"]+ ))++ # Quick Ratio (Acid Test)+ if current_liabilities > 0:+ quick_assets = current_assets - inventory # Excluding inventory+ quick_ratio = self.safe_divide(quick_assets, current_liabilities)+ benchmark = self.liquidity_benchmarks.get('quick_ratio', {})+ risk_level = self.assess_risk_level(quick_ratio, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.LIQUIDITY,+ metric_name="Quick Ratio",+ value=quick_ratio,+ interpretation=self.generate_interpretation("quick ratio", quick_ratio, risk_level,+ AnalysisType.LIQUIDITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(quick_ratio, industry_data.get(+ 'quick_ratio') if industry_data else None),+ methodology="(Current Assets - Inventory) / Current Liabilities",+ limitations=["Assumes receivables are readily collectible"]+ ))++ # Cash Ratio+ if current_liabilities > 0:+ cash_ratio = self.safe_divide(cash_equivalents, current_liabilities)+ benchmark = self.liquidity_benchmarks.get('cash_ratio', {})+ risk_level = self.assess_risk_level(cash_ratio, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.LIQUIDITY,+ metric_name="Cash Ratio",+ value=cash_ratio,+ interpretation=self.generate_interpretation("cash ratio", cash_ratio, risk_level,+ AnalysisType.LIQUIDITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(cash_ratio, industry_data.get(+ 'cash_ratio') if industry_data else None),+ methodology="Cash and Cash Equivalents / Current Liabilities",+ limitations=["Most conservative liquidity measure"]+ ))++ # Working Capital Analysis+ working_capital = current_assets - current_liabilities+ total_assets = balance_sheet.get('total_assets', 0)++ if total_assets > 0:+ working_capital_ratio = self.safe_divide(working_capital, total_assets)++ wc_interpretation = "Strong working capital position" if working_capital_ratio > 0.1 else "Adequate working capital" if working_capital_ratio > 0 else "Negative working capital - liquidity concern"+ wc_risk = RiskLevel.LOW if working_capital_ratio > 0.1 else RiskLevel.MODERATE if working_capital_ratio > 0 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.LIQUIDITY,+ metric_name="Working Capital Ratio",+ value=working_capital_ratio,+ interpretation=wc_interpretation,+ risk_level=wc_risk,+ methodology="(Current Assets - Current Liabilities) / Total Assets",+ limitations=["Industry-dependent optimal levels"]+ ))++ return results++ def _analyze_assets(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Comprehensive asset analysis"""+ results = []+ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ total_assets = balance_sheet.get('total_assets', 0)+ current_assets = balance_sheet.get('current_assets', 0)+ ppe_net = balance_sheet.get('ppe_net', 0)+ intangible_assets = balance_sheet.get('intangible_assets', 0)+ goodwill = balance_sheet.get('goodwill', 0)+ revenue = income_statement.get('revenue', 0)++ if total_assets == 0:+ return results++ # Asset Turnover+ if revenue > 0:+ # Calculate average assets if comparative data available+ avg_total_assets = total_assets+ if comparative_data and len(comparative_data) > 0:+ prev_assets = comparative_data[-1].balance_sheet.get('total_assets', 0)+ if prev_assets > 0:+ avg_total_assets = (total_assets + prev_assets) / 2++ asset_turnover = self.safe_divide(revenue, avg_total_assets)+ benchmark = self.activity_benchmarks.get('asset_turnover', {})+ risk_level = self.assess_risk_level(asset_turnover, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Asset Turnover",+ value=asset_turnover,+ interpretation=self.generate_interpretation("asset turnover", asset_turnover, risk_level,+ AnalysisType.ACTIVITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(asset_turnover, industry_data.get(+ 'asset_turnover') if industry_data else None),+ methodology="Revenue / Average Total Assets",+ limitations=["Influenced by asset age and accounting methods"]+ ))++ # Asset Composition Analysis+ current_asset_ratio = self.safe_divide(current_assets, total_assets)+ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Current Asset Ratio",+ value=current_asset_ratio,+ interpretation=f"Current assets represent {self.format_percentage(current_asset_ratio)} of total assets",+ risk_level=RiskLevel.LOW,+ methodology="Current Assets / Total Assets"+ ))++ # PPE Ratio+ ppe_ratio = self.safe_divide(ppe_net, total_assets)+ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="PPE Ratio",+ value=ppe_ratio,+ interpretation=f"Property, plant & equipment represents {self.format_percentage(ppe_ratio)} of total assets",+ risk_level=RiskLevel.LOW,+ methodology="Net PPE / Total Assets"+ ))++ # Intangible Assets Analysis+ if intangible_assets > 0:+ intangible_ratio = self.safe_divide(intangible_assets, total_assets)++ intangible_interpretation = "High intangible asset intensity - knowledge-based business" if intangible_ratio > 0.2 else "Moderate intangible assets" if intangible_ratio > 0.1 else "Low intangible asset base"+ intangible_risk = RiskLevel.MODERATE if intangible_ratio > 0.3 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Intangible Asset Ratio",+ value=intangible_ratio,+ interpretation=intangible_interpretation,+ risk_level=intangible_risk,+ methodology="Intangible Assets / Total Assets",+ limitations=["Requires assessment of asset impairment risk"]+ ))++ # Goodwill Analysis+ if goodwill > 0:+ goodwill_ratio = self.safe_divide(goodwill, total_assets)++ goodwill_interpretation = "Significant goodwill from acquisitions - monitor for impairment" if goodwill_ratio > 0.15 else "Moderate goodwill level" if goodwill_ratio > 0.05 else "Low goodwill"+ goodwill_risk = RiskLevel.MODERATE if goodwill_ratio > 0.2 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Goodwill Ratio",+ value=goodwill_ratio,+ interpretation=goodwill_interpretation,+ risk_level=goodwill_risk,+ methodology="Goodwill / Total Assets",+ limitations=["Subject to impairment testing and write-downs"]+ ))++ # Asset Quality Assessment+ results.extend(self._assess_asset_quality(statements, comparative_data))++ return results++ def _analyze_liabilities(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Comprehensive liability analysis"""+ results = []+ balance_sheet = statements.balance_sheet++ total_assets = balance_sheet.get('total_assets', 0)+ total_liabilities = balance_sheet.get('total_liabilities', 0)+ total_equity = balance_sheet.get('total_equity', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ long_term_debt = balance_sheet.get('long_term_debt', 0)+ short_term_debt = balance_sheet.get('short_term_debt', 0)++ if total_assets == 0:+ return results++ # Total debt calculation+ total_debt = long_term_debt + short_term_debt++ # Debt-to-Equity Ratio+ if total_equity > 0:+ debt_to_equity = self.safe_divide(total_debt, total_equity)+ benchmark = self.solvency_benchmarks.get('debt_to_equity', {})+ risk_level = self.assess_risk_level(debt_to_equity, benchmark, higher_is_better=False)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Debt-to-Equity Ratio",+ value=debt_to_equity,+ interpretation=self.generate_interpretation("debt-to-equity ratio", debt_to_equity, risk_level,+ AnalysisType.SOLVENCY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(debt_to_equity, industry_data.get(+ 'debt_to_equity') if industry_data else None),+ methodology="Total Debt / Total Equity",+ limitations=["Does not consider off-balance-sheet obligations"]+ ))++ # Debt-to-Assets Ratio+ debt_to_assets = self.safe_divide(total_debt, total_assets)+ benchmark = self.solvency_benchmarks.get('debt_to_assets', {})+ risk_level = self.assess_risk_level(debt_to_assets, benchmark, higher_is_better=False)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Debt-to-Assets Ratio",+ value=debt_to_assets,+ interpretation=self.generate_interpretation("debt-to-assets ratio", debt_to_assets, risk_level,+ AnalysisType.SOLVENCY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(debt_to_assets, industry_data.get(+ 'debt_to_assets') if industry_data else None),+ methodology="Total Debt / Total Assets",+ limitations=["Asset values may not reflect market values"]+ ))++ # Liability Structure Analysis+ current_liability_ratio = self.safe_divide(current_liabilities, total_assets)+ long_term_liability_ratio = self.safe_divide(long_term_debt, total_assets)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Current Liability Ratio",+ value=current_liability_ratio,+ interpretation=f"Current liabilities represent {self.format_percentage(current_liability_ratio)} of total assets",+ risk_level=RiskLevel.HIGH if current_liability_ratio > 0.4 else RiskLevel.MODERATE if current_liability_ratio > 0.25 else RiskLevel.LOW,+ methodology="Current Liabilities / Total Assets"+ ))++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Long-term Debt Ratio",+ value=long_term_liability_ratio,+ interpretation=f"Long-term debt represents {self.format_percentage(long_term_liability_ratio)} of total assets",+ risk_level=RiskLevel.HIGH if long_term_liability_ratio > 0.4 else RiskLevel.MODERATE if long_term_liability_ratio > 0.25 else RiskLevel.LOW,+ methodology="Long-term Debt / Total Assets"+ ))++ # Debt Maturity Analysis+ if total_debt > 0:+ short_term_debt_ratio = self.safe_divide(short_term_debt, total_debt)++ maturity_interpretation = "High short-term debt concentration - refinancing risk" if short_term_debt_ratio > 0.5 else "Balanced debt maturity profile" if short_term_debt_ratio > 0.2 else "Predominantly long-term debt structure"+ maturity_risk = RiskLevel.HIGH if short_term_debt_ratio > 0.6 else RiskLevel.MODERATE if short_term_debt_ratio > 0.4 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Short-term Debt Concentration",+ value=short_term_debt_ratio,+ interpretation=maturity_interpretation,+ risk_level=maturity_risk,+ methodology="Short-term Debt / Total Debt",+ limitations=["Does not consider debt covenants or refinancing ability"]+ ))++ # Interest Coverage Analysis (if income statement data available)+ income_statement = statements.income_statement+ operating_income = income_statement.get('operating_income', 0)+ interest_expense = income_statement.get('interest_expense', 0)++ if interest_expense > 0:+ interest_coverage = self.safe_divide(operating_income, interest_expense)+ benchmark = self.solvency_benchmarks.get('interest_coverage', {})+ risk_level = self.assess_risk_level(interest_coverage, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Interest Coverage Ratio",+ value=interest_coverage,+ interpretation=self.generate_interpretation("interest coverage ratio", interest_coverage, risk_level,+ AnalysisType.SOLVENCY),+ risk_level=risk_level,+ methodology="Operating Income / Interest Expense",+ limitations=["Based on current operating performance"]+ ))++ return results++ def _analyze_equity(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Comprehensive equity analysis"""+ results = []+ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ total_assets = balance_sheet.get('total_assets', 0)+ total_equity = balance_sheet.get('total_equity', 0)+ common_stock = balance_sheet.get('common_stock', 0)+ retained_earnings = balance_sheet.get('retained_earnings', 0)+ treasury_stock = balance_sheet.get('treasury_stock', 0)+ intangible_assets = balance_sheet.get('intangible_assets', 0)+ goodwill = balance_sheet.get('goodwill', 0)++ if total_assets == 0:+ return results++ # Equity Ratio+ equity_ratio = self.safe_divide(total_equity, total_assets)++ equity_interpretation = "Strong equity position - low financial leverage" if equity_ratio > 0.6 else "Moderate equity position" if equity_ratio > 0.4 else "High financial leverage - elevated risk"+ equity_risk = RiskLevel.LOW if equity_ratio > 0.5 else RiskLevel.MODERATE if equity_ratio > 0.3 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Equity Ratio",+ value=equity_ratio,+ interpretation=equity_interpretation,+ risk_level=equity_risk,+ benchmark_comparison=self.compare_to_industry(equity_ratio,+ industry_data.get('equity_ratio') if industry_data else None),+ methodology="Total Equity / Total Assets"+ ))++ # Equity Multiplier+ if total_equity > 0:+ equity_multiplier = self.safe_divide(total_assets, total_equity)++ multiplier_interpretation = "High financial leverage" if equity_multiplier > 3 else "Moderate financial leverage" if equity_multiplier > 2 else "Conservative financial leverage"+ multiplier_risk = RiskLevel.HIGH if equity_multiplier > 4 else RiskLevel.MODERATE if equity_multiplier > 2.5 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Equity Multiplier",+ value=equity_multiplier,+ interpretation=multiplier_interpretation,+ risk_level=multiplier_risk,+ methodology="Total Assets / Total Equity",+ limitations=["Component of DuPont analysis"]+ ))++ # Retained Earnings Analysis+ if total_equity > 0 and retained_earnings != 0:+ retained_earnings_ratio = self.safe_divide(retained_earnings, total_equity)++ re_interpretation = "Strong retained earnings base" if retained_earnings_ratio > 0.5 else "Moderate retained earnings" if retained_earnings_ratio > 0.2 else "Low retained earnings - recent losses or high dividends"+ re_risk = RiskLevel.LOW if retained_earnings_ratio > 0.3 else RiskLevel.MODERATE if retained_earnings_ratio > 0 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Retained Earnings Ratio",+ value=retained_earnings_ratio,+ interpretation=re_interpretation,+ risk_level=re_risk,+ methodology="Retained Earnings / Total Equity"+ ))++ # Book Value per Share (if share data available)+ shares_outstanding = income_statement.get('shares_outstanding_basic', 0)+ if shares_outstanding > 0 and total_equity > 0:+ book_value_per_share = self.safe_divide(total_equity, shares_outstanding)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.VALUATION,+ metric_name="Book Value per Share",+ value=book_value_per_share,+ interpretation=f"Book value per share is ${book_value_per_share:.2f}",+ risk_level=RiskLevel.LOW,+ methodology="Total Equity / Shares Outstanding"+ ))++ # Tangible Book Value per Share+ tangible_equity = total_equity - intangible_assets - goodwill+ if tangible_equity > 0:+ tangible_bvps = self.safe_divide(tangible_equity, shares_outstanding)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.VALUATION,+ metric_name="Tangible Book Value per Share",+ value=tangible_bvps,+ interpretation=f"Tangible book value per share is ${tangible_bvps:.2f}",+ risk_level=RiskLevel.LOW,+ methodology="(Total Equity - Intangibles - Goodwill) / Shares Outstanding",+ limitations=["Excludes intangible asset value"]+ ))++ # Return on Equity (if net income available)+ net_income = income_statement.get('net_income', 0)+ if total_equity > 0 and net_income != 0:+ # Calculate average equity if comparative data available+ avg_equity = total_equity+ if comparative_data and len(comparative_data) > 0:+ prev_equity = comparative_data[-1].balance_sheet.get('total_equity', 0)+ if prev_equity > 0:+ avg_equity = (total_equity + prev_equity) / 2++ roe = self.safe_divide(net_income, avg_equity)+ benchmark = self.profitability_benchmarks.get('roe', {})+ risk_level = self.assess_risk_level(roe, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Return on Equity",+ value=roe,+ interpretation=self.generate_interpretation("return on equity", roe, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(roe, industry_data.get('roe') if industry_data else None),+ methodology="Net Income / Average Total Equity"+ ))++ return results++ def _assess_asset_quality(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Assess asset quality and potential impairment issues"""+ results = []+ balance_sheet = statements.balance_sheet++ # Asset age analysis (if depreciation data available)+ ppe_gross = balance_sheet.get('ppe_gross', 0)+ accumulated_depreciation = balance_sheet.get('accumulated_depreciation', 0)++ if ppe_gross > 0 and accumulated_depreciation > 0:+ asset_age_ratio = self.safe_divide(accumulated_depreciation, ppe_gross)++ age_interpretation = "Assets approaching end of useful life - significant capex likely needed" if asset_age_ratio > 0.7 else "Moderately aged assets" if asset_age_ratio > 0.5 else "Relatively new assets"+ age_risk = RiskLevel.HIGH if asset_age_ratio > 0.8 else RiskLevel.MODERATE if asset_age_ratio > 0.6 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Asset Age Ratio",+ value=asset_age_ratio,+ interpretation=age_interpretation,+ risk_level=age_risk,+ methodology="Accumulated Depreciation / Gross PPE",+ limitations=["Based on historical cost and depreciation methods"]+ ))++ # Impairment indicators+ impairment_indicators = self._identify_impairment_indicators(statements, comparative_data)+ if impairment_indicators:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Asset Impairment Indicators",+ value=len(impairment_indicators),+ interpretation=f"Identified {len(impairment_indicators)} potential impairment indicators",+ risk_level=RiskLevel.HIGH if len(impairment_indicators) > 2 else RiskLevel.MODERATE,+ limitations=impairment_indicators+ ))++ return results++ def _assess_financial_position_quality(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Assess overall financial position quality"""+ results = []++ # Balance sheet strength score+ balance_sheet = statements.balance_sheet++ # Quality factors+ quality_factors = []+ quality_score = 100++ # Factor 1: Liquidity position+ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ if current_liabilities > 0:+ current_ratio = self.safe_divide(current_assets, current_liabilities)+ if current_ratio >= 1.5:+ quality_factors.append("Strong liquidity position")+ elif current_ratio < 1.0:+ quality_score -= 20++ # Factor 2: Debt levels+ total_assets = balance_sheet.get('total_assets', 0)+ total_debt = balance_sheet.get('long_term_debt', 0) + balance_sheet.get('short_term_debt', 0)+ if total_assets > 0:+ debt_ratio = self.safe_divide(total_debt, total_assets)+ if debt_ratio > 0.6:+ quality_score -= 25+ elif debt_ratio < 0.3:+ quality_factors.append("Conservative debt levels")++ # Factor 3: Asset composition+ intangible_assets = balance_sheet.get('intangible_assets', 0)+ goodwill = balance_sheet.get('goodwill', 0)+ if total_assets > 0:+ intangible_ratio = self.safe_divide(intangible_assets + goodwill, total_assets)+ if intangible_ratio > 0.4:+ quality_score -= 15++ # Factor 4: Profitability (if available)+ income_statement = statements.income_statement+ net_income = income_statement.get('net_income', 0)+ if net_income < 0:+ quality_score -= 20++ quality_score = max(0, quality_score)++ quality_interpretation = "Excellent financial position" if quality_score > 80 else "Good financial position" if quality_score > 60 else "Fair financial position" if quality_score > 40 else "Weak financial position"+ quality_risk = RiskLevel.LOW if quality_score > 70 else RiskLevel.MODERATE if quality_score > 50 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Financial Position Quality Score",+ value=quality_score,+ interpretation=quality_interpretation,+ risk_level=quality_risk,+ recommendations=quality_factors,+ methodology="Composite score based on liquidity, leverage, asset quality, and profitability"+ ))++ return results++ def _perform_common_size_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Perform common-size balance sheet analysis"""+ results = []+ balance_sheet = statements.balance_sheet+ total_assets = balance_sheet.get('total_assets', 0)++ if total_assets == 0:+ return results++ # Asset composition as % of total assets+ asset_items = {+ 'Current Assets': balance_sheet.get('current_assets', 0),+ 'PPE Net': balance_sheet.get('ppe_net', 0),+ 'Intangible Assets': balance_sheet.get('intangible_assets', 0),+ 'Goodwill': balance_sheet.get('goodwill', 0)+ }++ for item_name, item_value in asset_items.items():+ if item_value > 0:+ common_size_pct = self.safe_divide(item_value, total_assets)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name=f"{item_name} as % of Total Assets",+ value=common_size_pct,+ interpretation=f"{item_name} represents {self.format_percentage(common_size_pct)} of total assets",+ risk_level=RiskLevel.LOW,+ methodology=f"{item_name} / Total Assets"+ ))++ # Liability and equity composition+ liability_equity_items = {+ 'Current Liabilities': balance_sheet.get('current_liabilities', 0),+ 'Long-term Debt': balance_sheet.get('long_term_debt', 0),+ 'Total Equity': balance_sheet.get('total_equity', 0)+ }++ for item_name, item_value in liability_equity_items.items():+ if item_value != 0: # Include negative values+ common_size_pct = self.safe_divide(item_value, total_assets)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name=f"{item_name} as % of Total Assets",+ value=common_size_pct,+ interpretation=f"{item_name} represents {self.format_percentage(common_size_pct)} of total assets",+ risk_level=RiskLevel.LOW,+ methodology=f"{item_name} / Total Assets"+ ))++ return results++ def _analyze_balance_sheet_relationships(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze key balance sheet relationships and efficiency metrics"""+ results = []++ # Asset-Liability matching analysis+ balance_sheet = statements.balance_sheet+ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ long_term_assets = balance_sheet.get('total_assets', 0) - current_assets+ long_term_debt = balance_sheet.get('long_term_debt', 0)++ # Financing appropriateness+ if long_term_assets > 0 and (long_term_debt + balance_sheet.get('total_equity', 0)) > 0:+ long_term_financing = long_term_debt + balance_sheet.get('total_equity', 0)+ financing_ratio = self.safe_divide(long_term_financing, long_term_assets)++ financing_interpretation = "Appropriate long-term financing for long-term assets" if financing_ratio >= 1.0 else "Potential maturity mismatch - long-term assets financed with short-term funds"+ financing_risk = RiskLevel.LOW if financing_ratio >= 1.0 else RiskLevel.MODERATE if financing_ratio >= 0.8 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Long-term Financing Ratio",+ value=financing_ratio,+ interpretation=financing_interpretation,+ risk_level=financing_risk,+ methodology="(Long-term Debt + Equity) / Long-term Assets",+ limitations=["Simplified maturity matching analysis"]+ ))++ return results++ def _identify_impairment_indicators(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[str]:+ """Identify potential asset impairment indicators"""+ indicators = []++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ # Declining profitability+ net_income = income_statement.get('net_income', 0)+ if net_income < 0:+ indicators.append("Negative net income may indicate asset impairment")++ # High goodwill relative to market cap (would need market data)+ goodwill = balance_sheet.get('goodwill', 0)+ total_assets = balance_sheet.get('total_assets', 0)+ if goodwill > 0 and total_assets > 0:+ goodwill_ratio = self.safe_divide(goodwill, total_assets)+ if goodwill_ratio > 0.3:+ indicators.append("High goodwill concentration - monitor for impairment")++ # Declining asset utilization+ if comparative_data and len(comparative_data) > 0:+ revenue = income_statement.get('revenue', 0)+ prev_revenue = comparative_data[-1].income_statement.get('revenue', 0)++ if prev_revenue > 0 and revenue < prev_revenue * 0.9: # 10% decline+ indicators.append("Significant revenue decline may indicate asset impairment")++ return indicators++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key balance sheet metrics"""+ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ metrics = {}++ # Liquidity metrics+ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ cash_equivalents = balance_sheet.get('cash_equivalents', 0)++ if current_liabilities > 0:+ metrics['current_ratio'] = self.safe_divide(current_assets, current_liabilities)+ metrics['quick_ratio'] = self.safe_divide(current_assets - balance_sheet.get('inventory', 0),+ current_liabilities)+ metrics['cash_ratio'] = self.safe_divide(cash_equivalents, current_liabilities)++ # Solvency metrics+ total_assets = balance_sheet.get('total_assets', 0)+ total_equity = balance_sheet.get('total_equity', 0)+ total_debt = balance_sheet.get('long_term_debt', 0) + balance_sheet.get('short_term_debt', 0)++ if total_equity > 0:+ metrics['debt_to_equity'] = self.safe_divide(total_debt, total_equity)+ metrics['equity_multiplier'] = self.safe_divide(total_assets, total_equity)++ if total_assets > 0:+ metrics['debt_to_assets'] = self.safe_divide(total_debt, total_assets)+ metrics['equity_ratio'] = self.safe_divide(total_equity, total_assets)++ # Activity metrics+ revenue = income_statement.get('revenue', 0)+ if total_assets > 0 and revenue > 0:+ metrics['asset_turnover'] = self.safe_divide(revenue, total_assets)++ # Return metrics+ net_income = income_statement.get('net_income', 0)+ if total_assets > 0:+ metrics['roa'] = self.safe_divide(net_income, total_assets)+ if total_equity > 0:+ metrics['roe'] = self.safe_divide(net_income, total_equity)++ return metrics++ def create_liquidity_analysis(self, statements: FinancialStatements) -> LiquidityAnalysis:+ """Create comprehensive liquidity analysis object"""+ balance_sheet = statements.balance_sheet++ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ cash_equivalents = balance_sheet.get('cash_equivalents', 0)+ inventory = balance_sheet.get('inventory', 0)++ # Calculate ratios+ current_ratio = self.safe_divide(current_assets, current_liabilities)+ quick_ratio = self.safe_divide(current_assets - inventory, current_liabilities)+ cash_ratio = self.safe_divide(cash_equivalents, current_liabilities)++ working_capital = current_assets - current_liabilities+ total_assets = balance_sheet.get('total_assets', 0)+ working_capital_ratio = self.safe_divide(working_capital, total_assets)++ # Assess liquidity quality+ quality_score = 100+ if current_ratio < 1.0:+ quality_score -= 30+ elif current_ratio < 1.2:+ quality_score -= 15++ if quick_ratio < 0.8:+ quality_score -= 20++ if cash_ratio < 0.1:+ quality_score -= 10++ quality_score = max(0, quality_score)++ # Determine risk level+ if quality_score > 80:+ risk_level = RiskLevel.LOW+ elif quality_score > 60:+ risk_level = RiskLevel.MODERATE+ else:+ risk_level = RiskLevel.HIGH++ return LiquidityAnalysis(+ current_ratio=current_ratio,+ quick_ratio=quick_ratio,+ cash_ratio=cash_ratio,+ working_capital=working_capital,+ working_capital_ratio=working_capital_ratio,+ net_working_capital=working_capital,+ liquidity_quality_score=quality_score,+ liquidity_risk_level=risk_level+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/cash_flow.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/cash_flow.pynew file mode 100644index 000000000..3c5452abf--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/cash_flow.py@@ -0,0 +1,1042 @@++"""+Financial Statement Cash Flow Module+========================================++Cash flow statement analysis and liquidity assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class CashFlowMethod(Enum):+ """Cash flow statement preparation methods"""+ DIRECT = "direct"+ INDIRECT = "indirect"+++class CashFlowQuality(Enum):+ """Cash flow quality classification"""+ HIGH_QUALITY = "high_quality"+ MODERATE_QUALITY = "moderate_quality"+ LOW_QUALITY = "low_quality"+ MANIPULATED = "manipulated"+++class CashFlowTrend(Enum):+ """Cash flow trend patterns"""+ STRENGTHENING = "strengthening"+ STABLE = "stable"+ WEAKENING = "weakening"+ VOLATILE = "volatile"+++@dataclass+class CashFlowQualityAnalysis:+ """Comprehensive cash flow quality assessment"""+ operating_cash_quality: float+ investing_cash_quality: float+ financing_cash_quality: float+ overall_quality_score: float+ quality_indicators: List[str] = field(default_factory=list)+ red_flags: List[str] = field(default_factory=list)+ earnings_cash_correlation: float = None+ cash_earnings_ratio: float = None+++@dataclass+class FreeCashFlowAnalysis:+ """Free cash flow calculations and analysis"""+ fcf_firm: float+ fcf_equity: float+ fcf_yield: float = None+ fcf_growth_rate: float = None+ fcf_volatility: float = None+ capex_intensity: float = None+ fcf_conversion_ratio: float = None+ sustainability_score: float = None+++@dataclass+class CashFlowRatios:+ """Comprehensive cash flow ratio analysis"""+ # Performance ratios+ operating_cash_flow_ratio: float+ cash_flow_margin: float+ cash_return_on_assets: float++ # Coverage ratios+ cash_coverage_ratio: float+ debt_coverage_ratio: float+ dividend_coverage_ratio: float+ capex_coverage_ratio: float++ # Quality ratios+ operating_cash_to_net_income: float+ cash_to_earnings: float+ quality_of_earnings: float+++class CashFlowAnalyzer(BaseAnalyzer):+ """+ Comprehensive cash flow statement analyzer implementing CFA Institute standards.+ Covers operating, investing, financing activities, FCF analysis, and quality assessment.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_cash_flow_formulas()+ self._initialize_cash_flow_benchmarks()++ def _initialize_cash_flow_formulas(self):+ """Initialize cash flow specific formulas"""+ self.formula_registry.update({+ 'operating_cash_flow_ratio': lambda ocf, current_liabs: self.safe_divide(ocf, current_liabs),+ 'cash_flow_margin': lambda ocf, revenue: self.safe_divide(ocf, revenue),+ 'cash_return_on_assets': lambda ocf, total_assets: self.safe_divide(ocf, total_assets),+ 'free_cash_flow_firm': lambda ocf, capex: ocf - capex,+ 'free_cash_flow_equity': lambda fcf_firm, net_debt_payments: fcf_firm - net_debt_payments,+ 'cash_coverage_ratio': lambda ocf, debt_payments: self.safe_divide(ocf, debt_payments),+ 'quality_of_earnings': lambda ocf, net_income: self.safe_divide(ocf, net_income),+ 'capex_intensity': lambda capex, revenue: self.safe_divide(capex, revenue)+ })++ def _initialize_cash_flow_benchmarks(self):+ """Initialize cash flow specific benchmarks"""+ self.cash_flow_benchmarks = {+ 'operating_cash_flow_ratio': {'excellent': 0.4, 'good': 0.25, 'adequate': 0.15, 'poor': 0.1},+ 'cash_flow_margin': {'excellent': 0.2, 'good': 0.15, 'adequate': 0.1, 'poor': 0.05},+ 'quality_of_earnings': {'excellent': 1.2, 'good': 1.0, 'adequate': 0.8, 'poor': 0.6},+ 'cash_coverage_ratio': {'excellent': 3.0, 'good': 2.0, 'adequate': 1.5, 'poor': 1.0},+ 'fcf_margin': {'excellent': 0.15, 'good': 0.1, 'adequate': 0.05, 'poor': 0.02}+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive cash flow statement analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all cash flow aspects+ """+ results = []++ # Validate data sufficiency+ required_fields = ['operating_cash_flow']+ is_sufficient, missing_fields = self.validate_data_sufficiency(statements, required_fields)++ if not is_sufficient:+ if self.logger:+ self.logger.warning(f"Insufficient data for complete analysis. Missing: {missing_fields}")++ # Operating cash flow analysis+ results.extend(self._analyze_operating_cash_flow(statements, comparative_data, industry_data))++ # Investing cash flow analysis+ results.extend(self._analyze_investing_cash_flow(statements, comparative_data))++ # Financing cash flow analysis+ results.extend(self._analyze_financing_cash_flow(statements, comparative_data))++ # Free cash flow analysis+ results.extend(self._analyze_free_cash_flow(statements, comparative_data, industry_data))++ # Cash flow ratios+ results.extend(self._calculate_cash_flow_ratios(statements, comparative_data, industry_data))++ # Cash flow quality assessment+ results.extend(self._assess_cash_flow_quality(statements, comparative_data))++ # Statement linkages+ results.extend(self._analyze_statement_linkages(statements, comparative_data))++ # IFRS vs US GAAP differences (if applicable)+ results.extend(self._analyze_reporting_differences(statements))++ return results++ def _analyze_operating_cash_flow(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze operating cash flow performance and quality"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ net_income = income_statement.get('net_income', 0)+ revenue = income_statement.get('revenue', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ # Operating Cash Flow Ratio+ if current_liabilities > 0:+ ocf_ratio = self.safe_divide(operating_cash_flow, current_liabilities)+ benchmark = self.cash_flow_benchmarks.get('operating_cash_flow_ratio', {})+ risk_level = self.assess_risk_level(ocf_ratio, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.LIQUIDITY,+ metric_name="Operating Cash Flow Ratio",+ value=ocf_ratio,+ interpretation=self.generate_interpretation("operating cash flow ratio", ocf_ratio, risk_level,+ AnalysisType.LIQUIDITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(ocf_ratio, industry_data.get(+ 'ocf_ratio') if industry_data else None),+ methodology="Operating Cash Flow / Current Liabilities",+ limitations=["Based on current period performance"]+ ))++ # Cash Flow Margin+ if revenue > 0:+ cf_margin = self.safe_divide(operating_cash_flow, revenue)+ benchmark = self.cash_flow_benchmarks.get('cash_flow_margin', {})+ risk_level = self.assess_risk_level(cf_margin, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Cash Flow Margin",+ value=cf_margin,+ interpretation=self.generate_interpretation("cash flow margin", cf_margin, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(cf_margin, industry_data.get(+ 'cf_margin') if industry_data else None),+ methodology="Operating Cash Flow / Revenue",+ limitations=["May vary with working capital changes"]+ ))++ # Cash Return on Assets+ if total_assets > 0:+ cash_roa = self.safe_divide(operating_cash_flow, total_assets)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Cash Return on Assets",+ value=cash_roa,+ interpretation=f"Cash return on assets of {self.format_percentage(cash_roa)} shows cash generation efficiency",+ risk_level=RiskLevel.LOW if cash_roa > 0.1 else RiskLevel.MODERATE if cash_roa > 0.05 else RiskLevel.HIGH,+ methodology="Operating Cash Flow / Total Assets"+ ))++ # Quality of Earnings+ if net_income != 0:+ quality_earnings = self.safe_divide(operating_cash_flow, net_income)+ benchmark = self.cash_flow_benchmarks.get('quality_of_earnings', {})++ quality_interpretation = "High earnings quality - strong cash conversion" if quality_earnings >= 1.0 else "Moderate earnings quality" if quality_earnings >= 0.8 else "Low earnings quality - poor cash conversion"+ quality_risk = RiskLevel.LOW if quality_earnings >= 1.0 else RiskLevel.MODERATE if quality_earnings >= 0.7 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Quality of Earnings",+ value=quality_earnings,+ interpretation=quality_interpretation,+ risk_level=quality_risk,+ methodology="Operating Cash Flow / Net Income",+ limitations=["Single period comparison - trends are more meaningful"]+ ))++ # Working capital impact analysis+ results.extend(self._analyze_working_capital_impact(statements, comparative_data))++ return results++ def _analyze_investing_cash_flow(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze investing cash flow activities"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ investing_cash_flow = cash_flow.get('investing_cash_flow', 0)+ capex = cash_flow.get('capex', 0)+ acquisitions = cash_flow.get('acquisitions', 0)+ asset_sales = cash_flow.get('asset_sales', 0)+ revenue = income_statement.get('revenue', 0)++ # Capital Expenditure Analysis+ if revenue > 0 and capex > 0:+ capex_intensity = self.safe_divide(capex, revenue)++ capex_interpretation = "High capital intensity - significant reinvestment" if capex_intensity > 0.1 else "Moderate capital intensity" if capex_intensity > 0.05 else "Low capital intensity"+ capex_risk = RiskLevel.MODERATE if capex_intensity > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Capital Expenditure Intensity",+ value=capex_intensity,+ interpretation=capex_interpretation,+ risk_level=capex_risk,+ methodology="Capital Expenditures / Revenue",+ limitations=["Industry-dependent optimal levels"]+ ))++ # Investment Strategy Analysis+ if investing_cash_flow != 0:+ if investing_cash_flow < 0:+ investment_interpretation = "Net investment in assets - growth or maintenance focus"+ investment_risk = RiskLevel.LOW+ else:+ investment_interpretation = "Net divestiture - asset sales or reduced investment"+ investment_risk = RiskLevel.MODERATE++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Investing Cash Flow",+ value=investing_cash_flow,+ interpretation=investment_interpretation,+ risk_level=investment_risk,+ methodology="Total cash flow from investing activities"+ ))++ # Acquisition vs Organic Growth+ if capex > 0 and acquisitions > 0:+ acquisition_ratio = self.safe_divide(acquisitions, capex + acquisitions)++ growth_interpretation = "Growth primarily through acquisitions" if acquisition_ratio > 0.5 else "Balanced acquisition and organic growth" if acquisition_ratio > 0.2 else "Primarily organic growth"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Acquisition vs Organic Growth",+ value=acquisition_ratio,+ interpretation=growth_interpretation,+ risk_level=RiskLevel.MODERATE if acquisition_ratio > 0.7 else RiskLevel.LOW,+ methodology="Acquisitions / (Acquisitions + CapEx)",+ limitations=["Acquisition strategy assessment requires multi-period analysis"]+ ))++ return results++ def _analyze_financing_cash_flow(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze financing cash flow activities"""+ results = []+ cash_flow = statements.cash_flow++ financing_cash_flow = cash_flow.get('financing_cash_flow', 0)+ debt_issued = cash_flow.get('debt_issued', 0)+ debt_repaid = cash_flow.get('debt_repaid', 0)+ equity_issued = cash_flow.get('equity_issued', 0)+ equity_repurchased = cash_flow.get('equity_repurchased', 0)+ dividends_paid = cash_flow.get('dividends_paid', 0)++ # Net Debt Activity+ net_debt_activity = debt_issued - debt_repaid+ if abs(net_debt_activity) > 0:+ debt_interpretation = "Net debt increase - leveraging up" if net_debt_activity > 0 else "Net debt reduction - deleveraging"+ debt_risk = RiskLevel.MODERATE if net_debt_activity > 0 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Net Debt Activity",+ value=net_debt_activity,+ interpretation=debt_interpretation,+ risk_level=debt_risk,+ methodology="Debt Issued - Debt Repaid"+ ))++ # Net Equity Activity+ net_equity_activity = equity_issued - equity_repurchased+ if abs(net_equity_activity) > 0:+ equity_interpretation = "Net equity increase - raising capital" if net_equity_activity > 0 else "Net equity reduction - returning capital to shareholders"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Net Equity Activity",+ value=net_equity_activity,+ interpretation=equity_interpretation,+ risk_level=RiskLevel.LOW,+ methodology="Equity Issued - Equity Repurchased"+ ))++ # Dividend Coverage Analysis+ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ if dividends_paid > 0 and operating_cash_flow > 0:+ dividend_coverage = self.safe_divide(operating_cash_flow, dividends_paid)++ coverage_interpretation = "Strong dividend coverage" if dividend_coverage > 2.0 else "Adequate dividend coverage" if dividend_coverage > 1.5 else "Weak dividend coverage"+ coverage_risk = RiskLevel.LOW if dividend_coverage > 2.0 else RiskLevel.MODERATE if dividend_coverage > 1.0 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Dividend Coverage Ratio",+ value=dividend_coverage,+ interpretation=coverage_interpretation,+ risk_level=coverage_risk,+ methodology="Operating Cash Flow / Dividends Paid",+ limitations=["Does not consider capital expenditure requirements"]+ ))++ # Financing Mix Analysis+ total_financing = abs(debt_issued) + abs(equity_issued) + abs(debt_repaid) + abs(equity_repurchased)+ if total_financing > 0:+ debt_financing_ratio = self.safe_divide(abs(debt_issued) + abs(debt_repaid), total_financing)++ financing_interpretation = "Debt-heavy financing activities" if debt_financing_ratio > 0.7 else "Balanced debt and equity financing" if debt_financing_ratio > 0.3 else "Equity-focused financing"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Debt Financing Ratio",+ value=debt_financing_ratio,+ interpretation=financing_interpretation,+ risk_level=RiskLevel.MODERATE if debt_financing_ratio > 0.8 else RiskLevel.LOW,+ methodology="Debt Activities / Total Financing Activities"+ ))++ return results++ def _analyze_free_cash_flow(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Comprehensive free cash flow analysis"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ capex = cash_flow.get('capex', 0)+ revenue = income_statement.get('revenue', 0)++ # Free Cash Flow to the Firm+ fcf_firm = operating_cash_flow - capex++ if revenue > 0:+ fcf_margin = self.safe_divide(fcf_firm, revenue)+ benchmark = self.cash_flow_benchmarks.get('fcf_margin', {})+ risk_level = self.assess_risk_level(fcf_margin, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Free Cash Flow Margin",+ value=fcf_margin,+ interpretation=self.generate_interpretation("free cash flow margin", fcf_margin, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(fcf_margin, industry_data.get(+ 'fcf_margin') if industry_data else None),+ methodology="(Operating Cash Flow - Capital Expenditures) / Revenue"+ ))++ # Free Cash Flow to Equity+ debt_issued = cash_flow.get('debt_issued', 0)+ debt_repaid = cash_flow.get('debt_repaid', 0)+ net_debt_payments = debt_repaid - debt_issued++ fcf_equity = fcf_firm - net_debt_payments++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Free Cash Flow to Equity",+ value=fcf_equity,+ interpretation=f"Free cash flow to equity of ${fcf_equity:,.0f} available for dividends and share repurchases",+ risk_level=RiskLevel.LOW if fcf_equity > 0 else RiskLevel.HIGH,+ methodology="FCF Firm - Net Debt Payments"+ ))++ # FCF Conversion Ratio+ net_income = income_statement.get('net_income', 0)+ if net_income > 0:+ fcf_conversion = self.safe_divide(fcf_firm, net_income)++ conversion_interpretation = "Excellent FCF conversion" if fcf_conversion > 1.0 else "Good FCF conversion" if fcf_conversion > 0.8 else "Poor FCF conversion"+ conversion_risk = RiskLevel.LOW if fcf_conversion > 0.8 else RiskLevel.MODERATE if fcf_conversion > 0.5 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="FCF Conversion Ratio",+ value=fcf_conversion,+ interpretation=conversion_interpretation,+ risk_level=conversion_risk,+ methodology="Free Cash Flow / Net Income",+ limitations=["High conversion indicates lower reinvestment or better working capital management"]+ ))++ # FCF Growth Analysis+ if comparative_data and len(comparative_data) > 0:+ fcf_values = []+ periods = []++ for i, past_statements in enumerate(comparative_data):+ past_ocf = past_statements.cash_flow.get('operating_cash_flow', 0)+ past_capex = past_statements.cash_flow.get('capex', 0)+ past_fcf = past_ocf - past_capex+ fcf_values.append(past_fcf)+ periods.append(f"Period-{len(comparative_data) - i}")++ fcf_values.append(fcf_firm)+ periods.append("Current")++ if len(fcf_values) > 1:+ fcf_trend = self.calculate_trend(fcf_values, periods)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="FCF Growth Trend",+ value=fcf_trend.growth_rate or 0,+ interpretation=fcf_trend.trend_analysis,+ risk_level=RiskLevel.LOW if fcf_trend.growth_rate and fcf_trend.growth_rate > 0 else RiskLevel.HIGH,+ methodology="Compound Annual Growth Rate of Free Cash Flow"+ ))++ return results++ def _calculate_cash_flow_ratios(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Calculate comprehensive cash flow ratios"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ capex = cash_flow.get('capex', 0)+ total_debt = balance_sheet.get('long_term_debt', 0) + balance_sheet.get('short_term_debt', 0)++ # Cash Coverage Ratio (for debt service)+ debt_payments = cash_flow.get('debt_repaid', 0)+ interest_expense = income_statement.get('interest_expense', 0)+ total_debt_service = debt_payments + interest_expense++ if total_debt_service > 0:+ cash_coverage = self.safe_divide(operating_cash_flow, total_debt_service)+ benchmark = self.cash_flow_benchmarks.get('cash_coverage_ratio', {})+ risk_level = self.assess_risk_level(cash_coverage, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Cash Coverage Ratio",+ value=cash_coverage,+ interpretation=self.generate_interpretation("cash coverage ratio", cash_coverage, risk_level,+ AnalysisType.SOLVENCY),+ risk_level=risk_level,+ methodology="Operating Cash Flow / (Debt Payments + Interest Expense)",+ limitations=["Based on current period cash flows"]+ ))++ # Debt Coverage Ratio+ if total_debt > 0:+ debt_coverage = self.safe_divide(operating_cash_flow, total_debt)++ debt_coverage_interpretation = "Strong debt coverage ability" if debt_coverage > 0.2 else "Adequate debt coverage" if debt_coverage > 0.1 else "Weak debt coverage ability"+ debt_coverage_risk = RiskLevel.LOW if debt_coverage > 0.15 else RiskLevel.MODERATE if debt_coverage > 0.08 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Debt Coverage Ratio",+ value=debt_coverage,+ interpretation=debt_coverage_interpretation,+ risk_level=debt_coverage_risk,+ methodology="Operating Cash Flow / Total Debt"+ ))++ # Capital Expenditure Coverage+ if capex > 0:+ capex_coverage = self.safe_divide(operating_cash_flow, capex)++ capex_coverage_interpretation = "Strong capex coverage - self-funding growth" if capex_coverage > 1.5 else "Adequate capex coverage" if capex_coverage > 1.0 else "Insufficient capex coverage - external funding needed"+ capex_coverage_risk = RiskLevel.LOW if capex_coverage > 1.2 else RiskLevel.MODERATE if capex_coverage > 0.8 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.SOLVENCY,+ metric_name="Capital Expenditure Coverage",+ value=capex_coverage,+ interpretation=capex_coverage_interpretation,+ risk_level=capex_coverage_risk,+ methodology="Operating Cash Flow / Capital Expenditures",+ limitations=["Does not consider maintenance vs growth capex split"]+ ))++ return results++ def _analyze_working_capital_impact(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze working capital changes impact on cash flow"""+ results = []+ cash_flow = statements.cash_flow++ working_capital_change = cash_flow.get('working_capital_change', 0)+ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)++ if working_capital_change != 0 and operating_cash_flow != 0:+ wc_impact = self.safe_divide(abs(working_capital_change), abs(operating_cash_flow))++ wc_interpretation = "Significant working capital impact on cash flow" if wc_impact > 0.2 else "Moderate working capital impact" if wc_impact > 0.1 else "Minimal working capital impact"+ wc_risk = RiskLevel.HIGH if wc_impact > 0.3 else RiskLevel.MODERATE if wc_impact > 0.15 else RiskLevel.LOW++ # Determine if working capital helped or hurt cash flow+ if working_capital_change < 0: # Negative change means working capital increased (cash outflow)+ impact_direction = "Working capital increase reduced operating cash flow"+ else: # Positive change means working capital decreased (cash inflow)+ impact_direction = "Working capital decrease boosted operating cash flow"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Working Capital Impact",+ value=wc_impact,+ interpretation=f"{wc_interpretation}. {impact_direction}",+ risk_level=wc_risk,+ methodology="|Working Capital Change| / |Operating Cash Flow|"+ ))++ # Individual working capital components analysis+ ar_change = cash_flow.get('accounts_receivable_change', 0)+ inventory_change = cash_flow.get('inventory_change', 0)+ ap_change = cash_flow.get('accounts_payable_change', 0)++ wc_components = {+ 'Accounts Receivable Change': ar_change,+ 'Inventory Change': inventory_change,+ 'Accounts Payable Change': ap_change+ }++ for component, change in wc_components.items():+ if abs(change) > 0:+ if 'Payable' in component:+ # For payables, increase is good for cash flow+ impact_description = "Improved cash flow" if change > 0 else "Reduced cash flow"+ else:+ # For receivables and inventory, increase is bad for cash flow+ impact_description = "Reduced cash flow" if change < 0 else "Improved cash flow"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name=component,+ value=change,+ interpretation=f"{component} change of ${change:,.0f} {impact_description}",+ risk_level=RiskLevel.LOW,+ methodology="Change in working capital component from cash flow statement"+ ))++ return results++ def _assess_cash_flow_quality(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Comprehensive cash flow quality assessment"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ net_income = income_statement.get('net_income', 0)++ # Cash flow quality indicators+ quality_indicators = []+ red_flags = []+ quality_score = 100++ # 1. Operating cash flow vs Net income relationship+ if net_income > 0:+ ocf_ni_ratio = self.safe_divide(operating_cash_flow, net_income)+ if ocf_ni_ratio >= 1.0:+ quality_indicators.append("Operating cash flow exceeds net income")+ elif ocf_ni_ratio < 0.7:+ red_flags.append("Operating cash flow significantly below net income")+ quality_score -= 20+ elif net_income < 0 and operating_cash_flow > 0:+ quality_indicators.append("Positive operating cash flow despite losses")+ elif net_income < 0 and operating_cash_flow < 0:+ red_flags.append("Both earnings and cash flow are negative")+ quality_score -= 30++ # 2. Cash flow trend consistency+ if comparative_data and len(comparative_data) >= 2:+ ocf_values = []+ for past_statements in comparative_data:+ past_ocf = past_statements.cash_flow.get('operating_cash_flow', 0)+ ocf_values.append(past_ocf)+ ocf_values.append(operating_cash_flow)++ # Check for declining trend+ declining_periods = sum(1 for i in range(1, len(ocf_values)) if ocf_values[i] < ocf_values[i - 1])+ if declining_periods > len(ocf_values) // 2:+ red_flags.append("Declining operating cash flow trend")+ quality_score -= 15+ else:+ quality_indicators.append("Stable or improving cash flow trend")++ # 3. Working capital manipulation indicators+ working_capital_change = cash_flow.get('working_capital_change', 0)+ if abs(working_capital_change) > abs(operating_cash_flow) * 0.3:+ red_flags.append("Large working capital changes may indicate manipulation")+ quality_score -= 10++ # 4. One-time items impact+ # This would require detailed cash flow statement analysis++ quality_score = max(0, quality_score)++ quality_interpretation = "High cash flow quality" if quality_score > 80 else "Moderate cash flow quality" if quality_score > 60 else "Low cash flow quality - requires investigation"+ quality_risk = RiskLevel.LOW if quality_score > 75 else RiskLevel.MODERATE if quality_score > 50 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Cash Flow Quality Score",+ value=quality_score,+ interpretation=quality_interpretation,+ risk_level=quality_risk,+ recommendations=quality_indicators,+ limitations=red_flags,+ methodology="Composite score based on multiple quality indicators"+ ))++ return results++ def _analyze_statement_linkages(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze linkages between cash flow statement and other financial statements"""+ results = []+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ # Cash flow to income statement reconciliation+ net_income_cf = cash_flow.get('net_income_cf', 0)+ net_income_is = income_statement.get('net_income', 0)++ if abs(net_income_cf - net_income_is) > 0.01: # Allow for rounding+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Income Statement Reconciliation",+ value=abs(net_income_cf - net_income_is),+ interpretation="Net income figures should match between statements",+ risk_level=RiskLevel.MODERATE,+ limitations=["Potential data quality issue or reporting difference"]+ ))++ # Cash reconciliation+ net_cash_change = cash_flow.get('net_cash_change', 0)+ cash_beginning = cash_flow.get('cash_beginning', 0)+ cash_ending = cash_flow.get('cash_ending', 0)+ cash_bs = balance_sheet.get('cash_equivalents', 0)++ # Check if ending cash matches balance sheet+ if abs(cash_ending - cash_bs) > 0.01:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Cash Balance Reconciliation",+ value=abs(cash_ending - cash_bs),+ interpretation="Ending cash should match balance sheet cash",+ risk_level=RiskLevel.MODERATE,+ limitations=["Potential classification or timing difference"]+ ))++ # Check net change calculation+ calculated_change = cash_ending - cash_beginning+ if abs(net_cash_change - calculated_change) > 0.01:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Net Cash Change Reconciliation",+ value=abs(net_cash_change - calculated_change),+ interpretation="Net cash change should equal ending minus beginning cash",+ risk_level=RiskLevel.HIGH,+ limitations=["Mathematical error in cash flow statement"]+ ))++ return results++ def _analyze_reporting_differences(self, statements: FinancialStatements) -> List[AnalysisResult]:+ """Analyze IFRS vs US GAAP differences in cash flow reporting"""+ results = []++ reporting_standard = statements.company_info.reporting_standard+ cash_flow = statements.cash_flow++ # Interest and dividend classification differences+ interest_paid = cash_flow.get('interest_paid', 0)+ dividends_received = cash_flow.get('dividends_received', 0)++ if reporting_standard == ReportingStandard.IFRS:+ if interest_paid != 0 or dividends_received != 0:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="IFRS Classification Flexibility",+ value=1.0,+ interpretation="Under IFRS, interest paid and dividends received can be classified in operating or financing activities",+ risk_level=RiskLevel.LOW,+ limitations=["Classification choice may affect comparability with US GAAP companies"],+ methodology="IFRS allows flexibility in interest and dividend classification"+ ))+ elif reporting_standard == ReportingStandard.US_GAAP:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="US GAAP Classification Rules",+ value=1.0,+ interpretation="Under US GAAP, interest paid is operating, dividends received are operating, dividends paid are financing",+ risk_level=RiskLevel.LOW,+ methodology="US GAAP has fixed classification rules for interest and dividends"+ ))++ return results++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key cash flow metrics"""+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement+ balance_sheet = statements.balance_sheet++ metrics = {}++ # Core cash flow metrics+ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ capex = cash_flow.get('capex', 0)++ metrics['operating_cash_flow'] = operating_cash_flow+ metrics['free_cash_flow_firm'] = operating_cash_flow - capex++ # Cash flow ratios+ revenue = income_statement.get('revenue', 0)+ net_income = income_statement.get('net_income', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ if revenue > 0:+ metrics['cash_flow_margin'] = self.safe_divide(operating_cash_flow, revenue)+ metrics['fcf_margin'] = self.safe_divide(operating_cash_flow - capex, revenue)++ if net_income != 0:+ metrics['quality_of_earnings'] = self.safe_divide(operating_cash_flow, net_income)++ if current_liabilities > 0:+ metrics['operating_cash_flow_ratio'] = self.safe_divide(operating_cash_flow, current_liabilities)++ if total_assets > 0:+ metrics['cash_return_on_assets'] = self.safe_divide(operating_cash_flow, total_assets)++ # Coverage ratios+ dividends_paid = cash_flow.get('dividends_paid', 0)+ if dividends_paid > 0:+ metrics['dividend_coverage'] = self.safe_divide(operating_cash_flow, dividends_paid)++ if capex > 0:+ metrics['capex_coverage'] = self.safe_divide(operating_cash_flow, capex)++ return metrics++ def create_cash_flow_quality_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> CashFlowQualityAnalysis:+ """Create comprehensive cash flow quality analysis object"""+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ investing_cash_flow = cash_flow.get('investing_cash_flow', 0)+ financing_cash_flow = cash_flow.get('financing_cash_flow', 0)+ net_income = income_statement.get('net_income', 0)++ # Operating cash quality assessment+ operating_quality = 100+ if net_income > 0:+ ocf_ratio = self.safe_divide(operating_cash_flow, net_income)+ if ocf_ratio < 0.8:+ operating_quality -= 30+ elif ocf_ratio < 1.0:+ operating_quality -= 15++ # Investing cash quality (sustainable vs one-time)+ investing_quality = 100+ capex = cash_flow.get('capex', 0)+ asset_sales = cash_flow.get('asset_sales', 0)+ if asset_sales > abs(capex):+ investing_quality -= 20 # Relying on asset sales++ # Financing cash quality+ financing_quality = 100+ debt_issued = cash_flow.get('debt_issued', 0)+ equity_issued = cash_flow.get('equity_issued', 0)+ if debt_issued > operating_cash_flow * 2:+ financing_quality -= 25 # High debt dependence++ # Overall quality score+ overall_quality = np.mean([operating_quality, investing_quality, financing_quality])++ # Quality indicators and red flags+ quality_indicators = []+ red_flags = []++ if operating_cash_flow > 0:+ quality_indicators.append("Positive operating cash flow")+ else:+ red_flags.append("Negative operating cash flow")++ if net_income > 0 and operating_cash_flow > net_income:+ quality_indicators.append("Operating cash flow exceeds net income")+ elif net_income > 0 and operating_cash_flow < net_income * 0.7:+ red_flags.append("Poor cash conversion from earnings")++ # Earnings-cash correlation+ earnings_cash_correlation = None+ cash_earnings_ratio = None++ if net_income != 0:+ cash_earnings_ratio = self.safe_divide(operating_cash_flow, net_income)++ return CashFlowQualityAnalysis(+ operating_cash_quality=operating_quality,+ investing_cash_quality=investing_quality,+ financing_cash_quality=financing_quality,+ overall_quality_score=overall_quality,+ quality_indicators=quality_indicators,+ red_flags=red_flags,+ earnings_cash_correlation=earnings_cash_correlation,+ cash_earnings_ratio=cash_earnings_ratio+ )++ def create_free_cash_flow_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> FreeCashFlowAnalysis:+ """Create comprehensive free cash flow analysis object"""+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ capex = cash_flow.get('capex', 0)+ debt_issued = cash_flow.get('debt_issued', 0)+ debt_repaid = cash_flow.get('debt_repaid', 0)++ # Calculate FCF+ fcf_firm = operating_cash_flow - capex+ fcf_equity = fcf_firm - (debt_repaid - debt_issued)++ # FCF metrics+ revenue = income_statement.get('revenue', 0)+ net_income = income_statement.get('net_income', 0)++ fcf_yield = None # Would need market cap data+ fcf_growth_rate = None+ fcf_volatility = None+ capex_intensity = self.safe_divide(capex, revenue) if revenue > 0 else None+ fcf_conversion_ratio = self.safe_divide(fcf_firm, net_income) if net_income > 0 else None++ # Calculate growth and volatility if historical data available+ if comparative_data and len(comparative_data) > 0:+ fcf_values = []+ for past_statements in comparative_data:+ past_ocf = past_statements.cash_flow.get('operating_cash_flow', 0)+ past_capex = past_statements.cash_flow.get('capex', 0)+ past_fcf = past_ocf - past_capex+ fcf_values.append(past_fcf)++ fcf_values.append(fcf_firm)++ if len(fcf_values) > 1:+ # Growth rate calculation+ if fcf_values[0] > 0:+ if len(fcf_values) == 2:+ fcf_growth_rate = (fcf_values[-1] / fcf_values[0]) - 1+ else:+ n_periods = len(fcf_values) - 1+ fcf_growth_rate = (fcf_values[-1] / fcf_values[0]) ** (1 / n_periods) - 1++ # Volatility calculation+ mean_fcf = np.mean(fcf_values)+ std_fcf = np.std(fcf_values)+ fcf_volatility = std_fcf / abs(mean_fcf) if mean_fcf != 0 else 0++ # Sustainability score+ sustainability_score = 100+ if fcf_firm < 0:+ sustainability_score -= 40+ if capex_intensity and capex_intensity > 0.15:+ sustainability_score -= 20+ if fcf_conversion_ratio and fcf_conversion_ratio < 0.5:+ sustainability_score -= 20++ sustainability_score = max(0, sustainability_score)++ return FreeCashFlowAnalysis(+ fcf_firm=fcf_firm,+ fcf_equity=fcf_equity,+ fcf_yield=fcf_yield,+ fcf_growth_rate=fcf_growth_rate,+ fcf_volatility=fcf_volatility,+ capex_intensity=capex_intensity,+ fcf_conversion_ratio=fcf_conversion_ratio,+ sustainability_score=sustainability_score+ )++ def convert_indirect_to_direct_method(self, statements: FinancialStatements) -> Dict[str, float]:+ """Convert cash flow from indirect to direct method presentation"""+ # This is a simplified conversion - in practice would require more detailed data+ cash_flow = statements.cash_flow+ income_statement = statements.income_statement++ # Start with net income+ net_income = cash_flow.get('net_income_cf', income_statement.get('net_income', 0))++ # Add back non-cash items+ depreciation = cash_flow.get('depreciation_cf', 0)+ amortization = cash_flow.get('amortization_cf', 0)+ stock_compensation = cash_flow.get('stock_compensation', 0)++ # Working capital changes+ ar_change = cash_flow.get('accounts_receivable_change', 0)+ inventory_change = cash_flow.get('inventory_change', 0)+ ap_change = cash_flow.get('accounts_payable_change', 0)++ # Approximate direct method components+ revenue = income_statement.get('revenue', 0)+ cash_received_from_customers = revenue + ar_change # Simplified++ cost_of_sales = income_statement.get('cost_of_sales', 0)+ cash_paid_to_suppliers = cost_of_sales - inventory_change - ap_change # Simplified++ operating_expenses = income_statement.get('operating_expenses', 0)+ cash_paid_for_expenses = operating_expenses - depreciation - amortization - stock_compensation++ direct_method = {+ 'cash_received_from_customers': cash_received_from_customers,+ 'cash_paid_to_suppliers': -abs(cash_paid_to_suppliers),+ 'cash_paid_for_operating_expenses': -abs(cash_paid_for_expenses),+ 'net_operating_cash_flow': cash_received_from_customers - abs(cash_paid_to_suppliers) - abs(+ cash_paid_for_expenses)+ }++ return direct_method\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/comprehensive_analyzer.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/comprehensive_analyzer.pynew file mode 100644index 000000000..eedd12616--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/comprehensive_analyzer.py@@ -0,0 +1,876 @@++"""+Financial Statement Comprehensive Analyzer Module+========================================++Comprehensive financial statement analysis and integration++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules and statement analyzers+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis, QualityAssessment+from ..core.data_processor import FinancialStatements, ReportingStandard+from .income_statement import IncomeStatementAnalyzer+from .balance_sheet import BalanceSheetAnalyzer+from .cash_flow import CashFlowAnalyzer+++class FinancialHealth(Enum):+ """Overall financial health classification"""+ EXCELLENT = "excellent"+ GOOD = "good"+ FAIR = "fair"+ POOR = "poor"+ DISTRESSED = "distressed"+++class BusinessModel(Enum):+ """Business model classification based on financial patterns"""+ ASSET_HEAVY = "asset_heavy"+ ASSET_LIGHT = "asset_light"+ GROWTH = "growth"+ MATURE = "mature"+ TURNAROUND = "turnaround"+ CYCLICAL = "cyclical"+++@dataclass+class IntegratedAnalysis:+ """Comprehensive integrated analysis results"""+ overall_financial_health: FinancialHealth+ business_model_type: BusinessModel+ key_strengths: List[str] = field(default_factory=list)+ key_weaknesses: List[str] = field(default_factory=list)+ critical_risks: List[str] = field(default_factory=list)+ strategic_recommendations: List[str] = field(default_factory=list)++ # Integrated scores+ liquidity_score: float = 0.0+ profitability_score: float = 0.0+ efficiency_score: float = 0.0+ leverage_score: float = 0.0+ growth_score: float = 0.0+ quality_score: float = 0.0++ # Overall composite score+ composite_score: float = 0.0+++@dataclass+class StatementLinkages:+ """Analysis of relationships between financial statements"""+ income_to_cash_quality: float+ balance_sheet_efficiency: float+ working_capital_management: float+ capital_allocation_effectiveness: float+ earnings_sustainability: float++ # Red flags and quality issues+ reconciliation_issues: List[str] = field(default_factory=list)+ quality_concerns: List[str] = field(default_factory=list)+ positive_indicators: List[str] = field(default_factory=list)+++@dataclass+class BusinessCycleAnalysis:+ """Analysis of where company is in business cycle"""+ lifecycle_stage: str+ growth_phase_indicators: List[str] = field(default_factory=list)+ maturity_indicators: List[str] = field(default_factory=list)+ decline_indicators: List[str] = field(default_factory=list)++ # Financial pattern analysis+ revenue_growth_pattern: str = ""+ profitability_pattern: str = ""+ cash_flow_pattern: str = ""+ investment_pattern: str = ""+++class ComprehensiveAnalyzer(BaseAnalyzer):+ """+ Comprehensive financial statement analyzer that integrates all statement analyses.+ Provides holistic view of financial performance, position, and quality.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)++ # Initialize component analyzers+ self.income_analyzer = IncomeStatementAnalyzer(enable_logging)+ self.balance_analyzer = BalanceSheetAnalyzer(enable_logging)+ self.cash_flow_analyzer = CashFlowAnalyzer(enable_logging)++ self._initialize_integration_weights()++ def _initialize_integration_weights(self):+ """Initialize weights for integrated scoring"""+ self.scoring_weights = {+ 'liquidity': 0.2,+ 'profitability': 0.25,+ 'efficiency': 0.15,+ 'leverage': 0.15,+ 'growth': 0.15,+ 'quality': 0.1+ }++ # Risk factor weights+ self.risk_weights = {+ RiskLevel.LOW: 100,+ RiskLevel.MODERATE: 70,+ RiskLevel.HIGH: 40,+ RiskLevel.VERY_HIGH: 20+ }++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive multi-statement analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of integrated analysis results+ """+ results = []++ # Run individual statement analyses+ income_results = self.income_analyzer.analyze(statements, comparative_data, industry_data)+ balance_results = self.balance_analyzer.analyze(statements, comparative_data, industry_data)+ cash_flow_results = self.cash_flow_analyzer.analyze(statements, comparative_data, industry_data)++ # Combine all results+ all_results = income_results + balance_results + cash_flow_results++ # Perform integrated analysis+ integrated_analysis = self._perform_integrated_analysis(all_results, statements, comparative_data)++ # Convert integrated analysis to AnalysisResult format+ results.extend(self._create_integrated_results(integrated_analysis, statements))++ # Analyze statement linkages+ results.extend(self._analyze_statement_linkages(statements, comparative_data))++ # Business cycle analysis+ results.extend(self._analyze_business_cycle(statements, comparative_data))++ # Risk assessment+ results.extend(self._perform_risk_assessment(all_results, statements))++ # Generate strategic insights+ results.extend(self._generate_strategic_insights(all_results, statements, comparative_data))++ return results++ def _perform_integrated_analysis(self, all_results: List[AnalysisResult],+ statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> IntegratedAnalysis:+ """Perform integrated analysis across all statements"""++ # Categorize results by analysis type+ results_by_type = {}+ for result in all_results:+ if result.analysis_type not in results_by_type:+ results_by_type[result.analysis_type] = []+ results_by_type[result.analysis_type].append(result)++ # Calculate component scores+ liquidity_score = self._calculate_component_score(results_by_type.get(AnalysisType.LIQUIDITY, []))+ profitability_score = self._calculate_component_score(results_by_type.get(AnalysisType.PROFITABILITY, []))+ efficiency_score = self._calculate_component_score(results_by_type.get(AnalysisType.ACTIVITY, []))+ leverage_score = self._calculate_component_score(results_by_type.get(AnalysisType.SOLVENCY, []))+ quality_score = self._calculate_component_score(results_by_type.get(AnalysisType.QUALITY, []))++ # Calculate growth score from trends+ growth_score = self._calculate_growth_score(statements, comparative_data)++ # Calculate composite score+ composite_score = (+ liquidity_score * self.scoring_weights['liquidity'] ++ profitability_score * self.scoring_weights['profitability'] ++ efficiency_score * self.scoring_weights['efficiency'] ++ leverage_score * self.scoring_weights['leverage'] ++ growth_score * self.scoring_weights['growth'] ++ quality_score * self.scoring_weights['quality']+ )++ # Determine overall financial health+ financial_health = self._determine_financial_health(composite_score, all_results)++ # Classify business model+ business_model = self._classify_business_model(statements, comparative_data)++ # Identify strengths and weaknesses+ strengths, weaknesses = self._identify_strengths_weaknesses(all_results)++ # Identify critical risks+ critical_risks = self._identify_critical_risks(all_results)++ # Generate strategic recommendations+ strategic_recommendations = self._generate_strategic_recommendations(all_results, statements)++ return IntegratedAnalysis(+ overall_financial_health=financial_health,+ business_model_type=business_model,+ key_strengths=strengths,+ key_weaknesses=weaknesses,+ critical_risks=critical_risks,+ strategic_recommendations=strategic_recommendations,+ liquidity_score=liquidity_score,+ profitability_score=profitability_score,+ efficiency_score=efficiency_score,+ leverage_score=leverage_score,+ growth_score=growth_score,+ quality_score=quality_score,+ composite_score=composite_score+ )++ def _calculate_component_score(self, results: List[AnalysisResult]) -> float:+ """Calculate component score based on risk levels"""+ if not results:+ return 50.0 # Neutral score if no data++ total_weight = 0+ weighted_score = 0++ for result in results:+ weight = 1.0 # Equal weight for now, could be refined+ score = self.risk_weights.get(result.risk_level, 50)++ weighted_score += score * weight+ total_weight += weight++ return weighted_score / total_weight if total_weight > 0 else 50.0++ def _calculate_growth_score(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> float:+ """Calculate growth score based on key metrics trends"""+ if not comparative_data or len(comparative_data) == 0:+ return 50.0 # Neutral if no historical data++ growth_factors = []++ # Revenue growth+ current_revenue = statements.income_statement.get('revenue', 0)+ prev_revenue = comparative_data[-1].income_statement.get('revenue', 0)+ if prev_revenue > 0:+ revenue_growth = (current_revenue / prev_revenue) - 1+ growth_factors.append(min(100, max(0, 50 + revenue_growth * 200))) # Scale to 0-100++ # Net income growth+ current_ni = statements.income_statement.get('net_income', 0)+ prev_ni = comparative_data[-1].income_statement.get('net_income', 0)+ if prev_ni > 0:+ ni_growth = (current_ni / prev_ni) - 1+ growth_factors.append(min(100, max(0, 50 + ni_growth * 200)))++ # Asset growth+ current_assets = statements.balance_sheet.get('total_assets', 0)+ prev_assets = comparative_data[-1].balance_sheet.get('total_assets', 0)+ if prev_assets > 0:+ asset_growth = (current_assets / prev_assets) - 1+ growth_factors.append(min(100, max(0, 50 + asset_growth * 150)))++ return np.mean(growth_factors) if growth_factors else 50.0++ def _determine_financial_health(self, composite_score: float, all_results: List[AnalysisResult]) -> FinancialHealth:+ """Determine overall financial health classification"""++ # Check for distressed indicators+ high_risk_count = sum(1 for result in all_results if result.risk_level == RiskLevel.HIGH)+ very_high_risk_count = sum(1 for result in all_results if result.risk_level == RiskLevel.VERY_HIGH)++ if very_high_risk_count > 2 or high_risk_count > 5:+ return FinancialHealth.DISTRESSED++ # Classify based on composite score+ if composite_score >= 85:+ return FinancialHealth.EXCELLENT+ elif composite_score >= 70:+ return FinancialHealth.GOOD+ elif composite_score >= 55:+ return FinancialHealth.FAIR+ elif composite_score >= 40:+ return FinancialHealth.POOR+ else:+ return FinancialHealth.DISTRESSED++ def _classify_business_model(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> BusinessModel:+ """Classify business model based on financial patterns"""++ balance_sheet = statements.balance_sheet+ income_statement = statements.income_statement++ total_assets = balance_sheet.get('total_assets', 0)+ ppe_net = balance_sheet.get('ppe_net', 0)+ revenue = income_statement.get('revenue', 0)+ net_income = income_statement.get('net_income', 0)++ # Asset intensity analysis+ asset_intensity = self.safe_divide(total_assets, revenue) if revenue > 0 else 0+ ppe_ratio = self.safe_divide(ppe_net, total_assets) if total_assets > 0 else 0++ # Growth analysis+ is_growing = False+ if comparative_data and len(comparative_data) > 0:+ prev_revenue = comparative_data[-1].income_statement.get('revenue', 0)+ if prev_revenue > 0:+ revenue_growth = (revenue / prev_revenue) - 1+ is_growing = revenue_growth > 0.1 # 10% growth threshold++ # Profitability analysis+ net_margin = self.safe_divide(net_income, revenue) if revenue > 0 else 0+ is_profitable = net_income > 0++ # Classification logic+ if asset_intensity > 2.0 or ppe_ratio > 0.4:+ return BusinessModel.ASSET_HEAVY+ elif asset_intensity < 0.8 and ppe_ratio < 0.2:+ return BusinessModel.ASSET_LIGHT+ elif is_growing and net_margin > 0:+ return BusinessModel.GROWTH+ elif not is_profitable and comparative_data:+ # Check if declining+ declining_periods = 0+ for i in range(min(3, len(comparative_data))):+ past_ni = comparative_data[-(i + 1)].income_statement.get('net_income', 0)+ if past_ni < 0:+ declining_periods += 1+ if declining_periods >= 2:+ return BusinessModel.TURNAROUND+ elif is_profitable and not is_growing:+ return BusinessModel.MATURE+ else:+ return BusinessModel.CYCLICAL++ def _identify_strengths_weaknesses(self, all_results: List[AnalysisResult]) -> Tuple[List[str], List[str]]:+ """Identify key strengths and weaknesses from analysis results"""++ strengths = []+ weaknesses = []++ # Group results by analysis type and risk level+ by_type_risk = {}+ for result in all_results:+ key = (result.analysis_type, result.risk_level)+ if key not in by_type_risk:+ by_type_risk[key] = []+ by_type_risk[key].append(result)++ # Identify strengths (low risk areas)+ for (analysis_type, risk_level), results in by_type_risk.items():+ if risk_level == RiskLevel.LOW and len(results) >= 2:+ if analysis_type == AnalysisType.LIQUIDITY:+ strengths.append("Strong liquidity position with adequate cash resources")+ elif analysis_type == AnalysisType.PROFITABILITY:+ strengths.append("Robust profitability across multiple metrics")+ elif analysis_type == AnalysisType.SOLVENCY:+ strengths.append("Conservative financial leverage and strong solvency")+ elif analysis_type == AnalysisType.ACTIVITY:+ strengths.append("Efficient asset utilization and operational management")+ elif analysis_type == AnalysisType.QUALITY:+ strengths.append("High quality financial reporting and earnings")++ # Identify weaknesses (high risk areas)+ for (analysis_type, risk_level), results in by_type_risk.items():+ if risk_level in [RiskLevel.HIGH, RiskLevel.VERY_HIGH]:+ if analysis_type == AnalysisType.LIQUIDITY:+ weaknesses.append("Liquidity concerns - potential difficulty meeting short-term obligations")+ elif analysis_type == AnalysisType.PROFITABILITY:+ weaknesses.append("Weak profitability performance requiring operational improvement")+ elif analysis_type == AnalysisType.SOLVENCY:+ weaknesses.append("High financial leverage creating elevated financial risk")+ elif analysis_type == AnalysisType.ACTIVITY:+ weaknesses.append("Inefficient asset utilization and operational inefficiencies")+ elif analysis_type == AnalysisType.QUALITY:+ weaknesses.append("Financial reporting quality concerns requiring investigation")++ return strengths, weaknesses++ def _identify_critical_risks(self, all_results: List[AnalysisResult]) -> List[str]:+ """Identify critical risks from analysis results"""++ critical_risks = []++ # Very high risk items are always critical+ very_high_risks = [r for r in all_results if r.risk_level == RiskLevel.VERY_HIGH]+ for risk in very_high_risks:+ critical_risks.append(f"Critical: {risk.metric_name} - {risk.interpretation}")++ # Multiple high risks in same category are critical+ high_risks_by_type = {}+ for result in all_results:+ if result.risk_level == RiskLevel.HIGH:+ if result.analysis_type not in high_risks_by_type:+ high_risks_by_type[result.analysis_type] = []+ high_risks_by_type[result.analysis_type].append(result)++ for analysis_type, risks in high_risks_by_type.items():+ if len(risks) >= 2:+ critical_risks.append(+ f"Multiple high-risk {analysis_type.value} indicators require immediate attention")++ # Specific risk combinations+ liquidity_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.LIQUIDITY and r.risk_level == RiskLevel.HIGH]+ solvency_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.SOLVENCY and r.risk_level == RiskLevel.HIGH]++ if liquidity_risks and solvency_risks:+ critical_risks.append("Combined liquidity and solvency risks create financial distress potential")++ return critical_risks++ def _generate_strategic_recommendations(self, all_results: List[AnalysisResult],+ statements: FinancialStatements) -> List[str]:+ """Generate strategic recommendations based on analysis"""++ recommendations = []++ # Liquidity recommendations+ liquidity_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.LIQUIDITY and r.risk_level in [RiskLevel.HIGH,+ RiskLevel.MODERATE]]+ if liquidity_risks:+ recommendations.append("Improve working capital management and consider establishing credit facilities")++ # Profitability recommendations+ profitability_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.PROFITABILITY and r.risk_level in [RiskLevel.HIGH,+ RiskLevel.MODERATE]]+ if profitability_risks:+ recommendations.append("Focus on cost optimization and revenue enhancement strategies")++ # Efficiency recommendations+ activity_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.ACTIVITY and r.risk_level in [RiskLevel.HIGH,+ RiskLevel.MODERATE]]+ if activity_risks:+ recommendations.append("Optimize asset utilization and improve operational efficiency")++ # Leverage recommendations+ solvency_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.SOLVENCY and r.risk_level in [RiskLevel.HIGH,+ RiskLevel.MODERATE]]+ if solvency_risks:+ recommendations.append("Consider debt reduction and strengthen balance sheet structure")++ # Quality recommendations+ quality_risks = [r for r in all_results if+ r.analysis_type == AnalysisType.QUALITY and r.risk_level in [RiskLevel.HIGH,+ RiskLevel.MODERATE]]+ if quality_risks:+ recommendations.append("Enhance financial reporting transparency and earnings quality")++ # Growth recommendations+ income_statement = statements.income_statement+ net_income = income_statement.get('net_income', 0)+ if net_income > 0:+ recommendations.append("Consider strategic investments for sustainable growth")+ else:+ recommendations.append("Develop turnaround strategy to restore profitability")++ return recommendations++ def _create_integrated_results(self, integrated_analysis: IntegratedAnalysis,+ statements: FinancialStatements) -> List[AnalysisResult]:+ """Convert integrated analysis to AnalysisResult format"""++ results = []++ # Overall financial health+ health_risk = RiskLevel.LOW if integrated_analysis.overall_financial_health in [FinancialHealth.EXCELLENT,+ FinancialHealth.GOOD] else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Overall Financial Health",+ value=integrated_analysis.composite_score,+ interpretation=f"Overall financial health is {integrated_analysis.overall_financial_health.value} with composite score of {integrated_analysis.composite_score:.1f}",+ risk_level=health_risk,+ methodology="Weighted composite of liquidity, profitability, efficiency, leverage, growth, and quality scores"+ ))++ # Business model classification+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Business Model Type",+ value=1.0,+ interpretation=f"Business model classified as {integrated_analysis.business_model_type.value}",+ risk_level=RiskLevel.LOW,+ methodology="Classification based on asset intensity, growth patterns, and profitability"+ ))++ # Component scores+ component_scores = {+ "Liquidity Score": integrated_analysis.liquidity_score,+ "Profitability Score": integrated_analysis.profitability_score,+ "Efficiency Score": integrated_analysis.efficiency_score,+ "Leverage Score": integrated_analysis.leverage_score,+ "Growth Score": integrated_analysis.growth_score,+ "Quality Score": integrated_analysis.quality_score+ }++ for score_name, score_value in component_scores.items():+ score_risk = RiskLevel.LOW if score_value > 70 else RiskLevel.MODERATE if score_value > 50 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name=score_name,+ value=score_value,+ interpretation=f"{score_name}: {score_value:.1f}/100",+ risk_level=score_risk,+ methodology="Composite score based on relevant financial metrics"+ ))++ # Key insights+ if integrated_analysis.key_strengths:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Key Strengths",+ value=len(integrated_analysis.key_strengths),+ interpretation="Key financial strengths identified",+ risk_level=RiskLevel.LOW,+ recommendations=integrated_analysis.key_strengths+ ))++ if integrated_analysis.key_weaknesses:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Key Weaknesses",+ value=len(integrated_analysis.key_weaknesses),+ interpretation="Key financial weaknesses requiring attention",+ risk_level=RiskLevel.HIGH,+ limitations=integrated_analysis.key_weaknesses+ ))++ return results++ def _analyze_statement_linkages(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze relationships and linkages between financial statements"""++ results = []++ # Income statement to cash flow linkage+ income_statement = statements.income_statement+ cash_flow = statements.cash_flow++ net_income = income_statement.get('net_income', 0)+ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)++ if net_income != 0:+ cash_quality_ratio = self.safe_divide(operating_cash_flow, net_income)++ cash_quality_interpretation = "Excellent cash conversion from earnings" if cash_quality_ratio > 1.2 else "Good cash quality" if cash_quality_ratio > 1.0 else "Moderate cash quality" if cash_quality_ratio > 0.8 else "Poor cash conversion quality"+ cash_quality_risk = RiskLevel.LOW if cash_quality_ratio > 1.0 else RiskLevel.MODERATE if cash_quality_ratio > 0.7 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Earnings-Cash Flow Quality",+ value=cash_quality_ratio,+ interpretation=cash_quality_interpretation,+ risk_level=cash_quality_risk,+ methodology="Operating Cash Flow / Net Income"+ ))++ # Balance sheet efficiency analysis+ balance_sheet = statements.balance_sheet+ revenue = income_statement.get('revenue', 0)+ total_assets = balance_sheet.get('total_assets', 0)++ if revenue > 0 and total_assets > 0:+ asset_turnover = self.safe_divide(revenue, total_assets)++ efficiency_interpretation = "High asset efficiency" if asset_turnover > 1.5 else "Moderate asset efficiency" if asset_turnover > 1.0 else "Low asset efficiency"+ efficiency_risk = RiskLevel.LOW if asset_turnover > 1.2 else RiskLevel.MODERATE if asset_turnover > 0.8 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Statement Integration - Asset Efficiency",+ value=asset_turnover,+ interpretation=efficiency_interpretation,+ risk_level=efficiency_risk,+ methodology="Revenue (IS) / Total Assets (BS)"+ ))++ # Working capital management integration+ current_assets = balance_sheet.get('current_assets', 0)+ current_liabilities = balance_sheet.get('current_liabilities', 0)+ working_capital_change = cash_flow.get('working_capital_change', 0)++ working_capital = current_assets - current_liabilities++ if abs(working_capital_change) > 0 and abs(working_capital) > 0:+ wc_efficiency = self.safe_divide(abs(working_capital_change), abs(working_capital))++ wc_interpretation = "Significant working capital volatility" if wc_efficiency > 0.2 else "Moderate working capital changes" if wc_efficiency > 0.1 else "Stable working capital management"+ wc_risk = RiskLevel.HIGH if wc_efficiency > 0.3 else RiskLevel.MODERATE if wc_efficiency > 0.15 else RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Working Capital Management Integration",+ value=wc_efficiency,+ interpretation=wc_interpretation,+ risk_level=wc_risk,+ methodology="|WC Change (CF)| / |Net Working Capital (BS)|"+ ))++ return results++ def _analyze_business_cycle(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Analyze where company is in business cycle"""++ results = []++ if not comparative_data or len(comparative_data) < 2:+ return results++ # Analyze trends over time+ income_statement = statements.income_statement++ # Revenue trend analysis+ revenue_values = []+ for past_statements in comparative_data:+ revenue_values.append(past_statements.income_statement.get('revenue', 0))+ revenue_values.append(income_statement.get('revenue', 0))++ # Net income trend analysis+ ni_values = []+ for past_statements in comparative_data:+ ni_values.append(past_statements.income_statement.get('net_income', 0))+ ni_values.append(income_statement.get('net_income', 0))++ # Determine lifecycle stage+ lifecycle_indicators = []++ # Growth stage indicators+ recent_revenue_growth = 0+ if len(revenue_values) >= 2 and revenue_values[-2] > 0:+ recent_revenue_growth = (revenue_values[-1] / revenue_values[-2]) - 1++ if recent_revenue_growth > 0.15:+ lifecycle_indicators.append("High revenue growth indicates growth stage")+ elif recent_revenue_growth > 0.05:+ lifecycle_indicators.append("Moderate growth suggests expansion phase")+ elif recent_revenue_growth < -0.05:+ lifecycle_indicators.append("Declining revenue suggests maturity or decline phase")+ else:+ lifecycle_indicators.append("Stable revenue indicates mature stage")++ # Profitability evolution+ positive_ni_periods = sum(1 for ni in ni_values if ni > 0)+ profitability_ratio = positive_ni_periods / len(ni_values)++ if profitability_ratio > 0.8:+ lifecycle_indicators.append("Consistent profitability indicates mature business model")+ elif profitability_ratio < 0.5:+ lifecycle_indicators.append("Inconsistent profitability suggests early stage or turnaround situation")++ # Determine overall lifecycle stage+ if recent_revenue_growth > 0.2 and profitability_ratio > 0.6:+ lifecycle_stage = "Growth Stage"+ elif recent_revenue_growth > 0.05 and profitability_ratio > 0.7:+ lifecycle_stage = "Expansion Stage"+ elif abs(recent_revenue_growth) < 0.05 and profitability_ratio > 0.8:+ lifecycle_stage = "Mature Stage"+ elif recent_revenue_growth < -0.1 or profitability_ratio < 0.4:+ lifecycle_stage = "Decline/Turnaround Stage"+ else:+ lifecycle_stage = "Transition Stage"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Business Lifecycle Stage",+ value=1.0,+ interpretation=f"Company appears to be in {lifecycle_stage}",+ risk_level=RiskLevel.LOW,+ recommendations=lifecycle_indicators,+ methodology="Analysis of revenue growth and profitability trends over time"+ ))++ return results++ def _perform_risk_assessment(self, all_results: List[AnalysisResult],+ statements: FinancialStatements) -> List[AnalysisResult]:+ """Perform comprehensive risk assessment"""++ results = []++ # Count risks by level+ risk_counts = {+ RiskLevel.LOW: 0,+ RiskLevel.MODERATE: 0,+ RiskLevel.HIGH: 0,+ RiskLevel.VERY_HIGH: 0+ }++ for result in all_results:+ risk_counts[result.risk_level] += 1++ total_metrics = len(all_results)+ high_risk_ratio = (risk_counts[RiskLevel.HIGH] + risk_counts[+ RiskLevel.VERY_HIGH]) / total_metrics if total_metrics > 0 else 0++ # Overall risk assessment+ if high_risk_ratio > 0.3:+ overall_risk = "High Risk"+ risk_level = RiskLevel.HIGH+ elif high_risk_ratio > 0.15:+ overall_risk = "Moderate Risk"+ risk_level = RiskLevel.MODERATE+ else:+ overall_risk = "Low Risk"+ risk_level = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Overall Risk Assessment",+ value=high_risk_ratio,+ interpretation=f"{overall_risk} - {high_risk_ratio:.1%} of metrics show elevated risk",+ risk_level=risk_level,+ methodology="Proportion of high and very high risk metrics"+ ))++ # Risk concentration analysis+ risk_by_type = {}+ for result in all_results:+ if result.risk_level in [RiskLevel.HIGH, RiskLevel.VERY_HIGH]:+ if result.analysis_type not in risk_by_type:+ risk_by_type[result.analysis_type] = 0+ risk_by_type[result.analysis_type] += 1++ if risk_by_type:+ max_risk_type = max(risk_by_type, key=risk_by_type.get)+ max_risk_count = risk_by_type[max_risk_type]++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Risk Concentration",+ value=max_risk_count,+ interpretation=f"Highest risk concentration in {max_risk_type.value} with {max_risk_count} high-risk metrics",+ risk_level=RiskLevel.HIGH if max_risk_count > 2 else RiskLevel.MODERATE,+ methodology="Analysis of risk distribution across financial areas"+ ))++ return results++ def _generate_strategic_insights(self, all_results: List[AnalysisResult],+ statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Generate high-level strategic insights"""++ results = []++ # Capital allocation insights+ cash_flow = statements.cash_flow+ operating_cash_flow = cash_flow.get('operating_cash_flow', 0)+ capex = cash_flow.get('capex', 0)+ dividends_paid = cash_flow.get('dividends_paid', 0)+ acquisitions = cash_flow.get('acquisitions', 0)++ total_capital_deployment = capex + dividends_paid + acquisitions++ if operating_cash_flow > 0 and total_capital_deployment > 0:+ capital_efficiency = self.safe_divide(total_capital_deployment, operating_cash_flow)++ capital_interpretation = "Aggressive capital deployment" if capital_efficiency > 1.0 else "Balanced capital allocation" if capital_efficiency > 0.7 else "Conservative capital deployment"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="Capital Allocation Strategy",+ value=capital_efficiency,+ interpretation=capital_interpretation,+ risk_level=RiskLevel.MODERATE if capital_efficiency > 1.2 else RiskLevel.LOW,+ methodology="(CapEx + Dividends + Acquisitions) / Operating Cash Flow"+ ))++ # Competitive position indicators+ income_statement = statements.income_statement+ revenue = income_statement.get('revenue', 0)+ gross_profit = revenue - income_statement.get('cost_of_sales', 0)++ if revenue > 0:+ gross_margin = self.safe_divide(gross_profit, revenue)++ competitive_strength = "Strong competitive position" if gross_margin > 0.4 else "Moderate competitive position" if gross_margin > 0.2 else "Weak competitive position"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Competitive Position Indicator",+ value=gross_margin,+ interpretation=competitive_strength,+ risk_level=RiskLevel.LOW if gross_margin > 0.3 else RiskLevel.MODERATE if gross_margin > 0.15 else RiskLevel.HIGH,+ methodology="Gross margin as proxy for competitive strength and pricing power"+ ))++ return results++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return comprehensive key metrics from all analyzers"""++ # Get metrics from individual analyzers+ income_metrics = self.income_analyzer.get_key_metrics(statements)+ balance_metrics = self.balance_analyzer.get_key_metrics(statements)+ cash_flow_metrics = self.cash_flow_analyzer.get_key_metrics(statements)++ # Combine all metrics+ all_metrics = {**income_metrics, **balance_metrics, **cash_flow_metrics}++ return all_metrics++ def create_integrated_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> IntegratedAnalysis:+ """Create comprehensive integrated analysis object"""++ # Run full analysis+ all_results = self.analyze(statements, comparative_data, industry_data)++ # Extract integrated analysis from results+ integrated_results = [r for r in all_results if "Score" in r.metric_name or "Health" in r.metric_name]++ # Create IntegratedAnalysis object (simplified version)+ return IntegratedAnalysis(+ overall_financial_health=FinancialHealth.GOOD, # Would be determined from analysis+ business_model_type=BusinessModel.MATURE, # Would be determined from analysis+ composite_score=75.0 # Would be calculated from component scores+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/income_statement.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/income_statement.pynew file mode 100644index 000000000..6dd368e57--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/income_statement.py@@ -0,0 +1,961 @@++"""+Financial Statement Income Statement Module+========================================++Income statement analysis and profitability assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Company financial statements and SEC filings+ - Management discussion and analysis sections+ - Auditor reports and financial statement footnotes+ - Industry benchmarks and competitor data+ - Economic indicators affecting financial performance++OUTPUT:+ - Financial analysis metrics and key performance indicators+ - Trend analysis and financial ratio calculations+ - Risk assessment and quality metrics+ - Comparative analysis and benchmarking results+ - Investment recommendations and insights++PARAMETERS:+ - analysis_period: Financial analysis period (default: 3 years)+ - industry_benchmark: Industry for comparative analysis (default: 'auto')+ - quality_threshold: Minimum financial quality score (default: 0.7)+ - growth_assumption: Growth rate assumption (default: 0.05)+ - currency: Reporting currency (default: 'USD')+"""+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Tuple, Union+from dataclasses import dataclass, field+from enum import Enum+import logging++# Import from core modules+from ..core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, \+ ComparativeAnalysis+from ..core.data_processor import FinancialStatements, ReportingStandard+++class RevenueRecognitionMethod(Enum):+ """Revenue recognition methods"""+ POINT_IN_TIME = "point_in_time"+ OVER_TIME = "over_time"+ PERCENTAGE_COMPLETION = "percentage_completion"+ COMPLETED_CONTRACT = "completed_contract"+ INSTALLMENT = "installment"+++class ExpenseRecognitionMethod(Enum):+ """Expense recognition methods"""+ MATCHING_PRINCIPLE = "matching"+ SYSTEMATIC_ALLOCATION = "systematic_allocation"+ IMMEDIATE_RECOGNITION = "immediate"+ CAPITALIZED = "capitalized"+++class IncomeQualityIndicator(Enum):+ """Income quality assessment indicators"""+ HIGH_QUALITY = "high_quality"+ MODERATE_QUALITY = "moderate_quality"+ LOW_QUALITY = "low_quality"+ RED_FLAG = "red_flag"+++@dataclass+class EPSAnalysis:+ """Comprehensive EPS analysis results"""+ basic_eps: float+ diluted_eps: float+ basic_shares: float+ diluted_shares: float+ dilution_effect: float+ eps_quality: IncomeQualityIndicator+ antidilutive_securities: bool+ eps_growth_rate: float = None+ eps_volatility: float = None+ normalized_eps: float = None+++@dataclass+class NonRecurringItemsAnalysis:+ """Analysis of non-recurring and unusual items"""+ total_non_recurring: float+ discontinued_operations: float+ unusual_items: float+ extraordinary_items: float+ restructuring_charges: float+ impairment_losses: float+ gains_losses_disposals: float+ impact_on_core_earnings: float+ frequency_analysis: str+ persistence_assessment: str+++@dataclass+class RevenueQualityAssessment:+ """Revenue quality and recognition analysis"""+ revenue_growth_rate: float+ revenue_volatility: float+ seasonality_factor: float+ revenue_concentration: float+ days_sales_outstanding: float+ revenue_quality_score: float+ recognition_issues: List[str] = field(default_factory=list)+ quality_indicators: List[str] = field(default_factory=list)+++class IncomeStatementAnalyzer(BaseAnalyzer):+ """+ Comprehensive income statement analyzer implementing CFA Institute standards.+ Covers revenue/expense recognition, EPS calculations, non-recurring items analysis.+ """++ def __init__(self, enable_logging: bool = True):+ super().__init__(enable_logging)+ self._initialize_income_formulas()+ self._initialize_quality_thresholds()++ def _initialize_income_formulas(self):+ """Initialize income statement specific formulas"""+ self.formula_registry.update({+ 'gross_profit_margin': lambda revenue, cogs: self.safe_divide(revenue - cogs, revenue),+ 'operating_profit_margin': lambda operating_income, revenue: self.safe_divide(operating_income, revenue),+ 'net_profit_margin': lambda net_income, revenue: self.safe_divide(net_income, revenue),+ 'ebitda_margin': lambda ebitda, revenue: self.safe_divide(ebitda, revenue),+ 'basic_eps': lambda net_income, shares: self.safe_divide(net_income, shares),+ 'diluted_eps': lambda net_income_diluted, diluted_shares: self.safe_divide(net_income_diluted,+ diluted_shares),+ 'tax_rate': lambda tax_expense, pretax_income: self.safe_divide(tax_expense, pretax_income),+ 'interest_coverage': lambda ebit, interest_expense: self.safe_divide(ebit, interest_expense)+ })++ def _initialize_quality_thresholds(self):+ """Initialize income quality assessment thresholds"""+ self.quality_thresholds.update({+ 'revenue_growth_volatility': {'low': 0.1, 'moderate': 0.2, 'high': 0.4},+ 'earnings_persistence': {'high': 0.8, 'moderate': 0.6, 'low': 0.4},+ 'accruals_ratio': {'good': 0.05, 'moderate': 0.1, 'poor': 0.2},+ 'non_recurring_frequency': {'rare': 0.1, 'occasional': 0.2, 'frequent': 0.4}+ })++ def analyze(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """+ Comprehensive income statement analysis++ Args:+ statements: Current period financial statements+ comparative_data: Historical financial statements for trend analysis+ industry_data: Industry benchmarks and peer data++ Returns:+ List of analysis results covering all income statement aspects+ """+ results = []++ # Validate data sufficiency+ required_fields = ['revenue', 'net_income', 'operating_income']+ is_sufficient, missing_fields = self.validate_data_sufficiency(statements, required_fields)++ if not is_sufficient:+ if self.logger:+ self.logger.warning(f"Insufficient data for complete analysis. Missing: {missing_fields}")++ # Core profitability analysis+ results.extend(self._analyze_profitability_ratios(statements, industry_data))++ # Revenue analysis+ results.extend(self._analyze_revenue_recognition(statements, comparative_data))++ # Expense analysis+ results.extend(self._analyze_expense_recognition(statements, comparative_data))++ # EPS analysis+ eps_results = self._analyze_earnings_per_share(statements, comparative_data)+ if eps_results:+ results.extend(eps_results)++ # Non-recurring items analysis+ results.extend(self._analyze_non_recurring_items(statements, comparative_data))++ # Income quality assessment+ results.extend(self._assess_income_quality(statements, comparative_data))++ # Common-size analysis+ results.extend(self._perform_common_size_analysis(statements, comparative_data))++ return results++ def _analyze_profitability_ratios(self, statements: FinancialStatements,+ industry_data: Optional[Dict] = None) -> List[AnalysisResult]:+ """Analyze core profitability ratios"""+ results = []+ income = statements.income_statement++ # Gross Profit Margin+ revenue = income.get('revenue', 0)+ cogs = income.get('cost_of_sales', 0)++ if revenue > 0:+ gross_margin = self.safe_divide(revenue - cogs, revenue)+ benchmark = self.profitability_benchmarks.get('gross_margin', {})+ risk_level = self.assess_risk_level(gross_margin, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Gross Profit Margin",+ value=gross_margin,+ interpretation=self.generate_interpretation("gross profit margin", gross_margin, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(gross_margin, industry_data.get(+ 'gross_margin') if industry_data else None),+ methodology="(Revenue - Cost of Sales) / Revenue",+ limitations=["Does not reflect operating efficiency or overhead costs"]+ ))++ # Operating Profit Margin+ operating_income = income.get('operating_income', 0)+ if revenue > 0 and operating_income is not None:+ operating_margin = self.safe_divide(operating_income, revenue)+ benchmark = self.profitability_benchmarks.get('operating_margin', {})+ risk_level = self.assess_risk_level(operating_margin, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Operating Profit Margin",+ value=operating_margin,+ interpretation=self.generate_interpretation("operating profit margin", operating_margin, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(operating_margin, industry_data.get(+ 'operating_margin') if industry_data else None),+ methodology="Operating Income / Revenue",+ limitations=["Excludes non-operating income and expenses"]+ ))++ # Net Profit Margin+ net_income = income.get('net_income', 0)+ if revenue > 0:+ net_margin = self.safe_divide(net_income, revenue)+ benchmark = self.profitability_benchmarks.get('net_margin', {})+ risk_level = self.assess_risk_level(net_margin, benchmark, higher_is_better=True)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Net Profit Margin",+ value=net_margin,+ interpretation=self.generate_interpretation("net profit margin", net_margin, risk_level,+ AnalysisType.PROFITABILITY),+ risk_level=risk_level,+ benchmark_comparison=self.compare_to_industry(net_margin, industry_data.get(+ 'net_margin') if industry_data else None),+ methodology="Net Income / Revenue",+ limitations=["May include non-recurring items affecting comparability"]+ ))++ # EBITDA Margin (if calculable)+ ebitda = self._calculate_ebitda(statements)+ if ebitda is not None and revenue > 0:+ ebitda_margin = self.safe_divide(ebitda, revenue)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="EBITDA Margin",+ value=ebitda_margin,+ interpretation=f"EBITDA margin of {self.format_percentage(ebitda_margin)} shows operational profitability before financing and accounting decisions",+ risk_level=self.assess_risk_level(ebitda_margin,+ self.profitability_benchmarks.get('operating_margin', {}),+ higher_is_better=True),+ methodology="(Operating Income + Depreciation + Amortization) / Revenue",+ limitations=["Does not reflect capital expenditure requirements or working capital needs"]+ ))++ return results++ def _analyze_revenue_recognition(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze revenue recognition and quality"""+ results = []+ income = statements.income_statement+ revenue = income.get('revenue', 0)++ if revenue <= 0:+ return results++ # Revenue growth analysis+ if comparative_data and len(comparative_data) > 0:+ prev_revenue = comparative_data[-1].income_statement.get('revenue', 0)+ if prev_revenue > 0:+ revenue_growth = (revenue / prev_revenue) - 1++ # Assess revenue growth quality+ if revenue_growth > 0.2:+ growth_quality = "Strong revenue growth - monitor sustainability"+ elif revenue_growth > 0.1:+ growth_quality = "Healthy revenue growth"+ elif revenue_growth > 0:+ growth_quality = "Modest revenue growth"+ elif revenue_growth > -0.05:+ growth_quality = "Flat revenue - investigate causes"+ else:+ growth_quality = "Declining revenue - significant concern"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Revenue Growth Rate",+ value=revenue_growth,+ interpretation=growth_quality,+ risk_level=RiskLevel.LOW if revenue_growth > 0.05 else RiskLevel.HIGH if revenue_growth < -0.05 else RiskLevel.MODERATE,+ methodology="(Current Revenue - Previous Revenue) / Previous Revenue",+ limitations=["Single period comparison may not reflect underlying trends"]+ ))++ # Revenue recognition quality indicators+ balance_sheet = statements.balance_sheet+ accounts_receivable = balance_sheet.get('accounts_receivable', 0)++ if accounts_receivable > 0 and revenue > 0:+ # Days Sales Outstanding+ dso = (accounts_receivable / revenue) * 365++ dso_interpretation = "Normal collection period" if dso <= 45 else "Extended collection period - monitor credit quality" if dso <= 90 else "Very long collection period - potential collection issues"+ dso_risk = RiskLevel.LOW if dso <= 45 else RiskLevel.MODERATE if dso <= 90 else RiskLevel.HIGH++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Days Sales Outstanding",+ value=dso,+ interpretation=dso_interpretation,+ risk_level=dso_risk,+ methodology="(Accounts Receivable / Revenue) × 365",+ limitations=["May vary by industry and seasonality"]+ ))++ # Check for potential revenue manipulation indicators+ revenue_quality_issues = self._identify_revenue_quality_issues(statements, comparative_data)+ if revenue_quality_issues:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Revenue Quality Assessment",+ value=len(revenue_quality_issues),+ interpretation=f"Identified {len(revenue_quality_issues)} potential revenue quality concerns",+ risk_level=RiskLevel.HIGH if len(revenue_quality_issues) > 2 else RiskLevel.MODERATE,+ limitations=revenue_quality_issues+ ))++ return results++ def _analyze_expense_recognition(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze expense recognition patterns and quality"""+ results = []+ income = statements.income_statement++ # Operating leverage analysis+ revenue = income.get('revenue', 0)+ operating_income = income.get('operating_income', 0)++ if comparative_data and len(comparative_data) > 0 and revenue > 0:+ prev_statements = comparative_data[-1]+ prev_revenue = prev_statements.income_statement.get('revenue', 0)+ prev_operating_income = prev_statements.income_statement.get('operating_income', 0)++ if prev_revenue > 0 and prev_operating_income != 0:+ revenue_change = (revenue / prev_revenue) - 1+ operating_change = (operating_income / prev_operating_income) - 1 if prev_operating_income != 0 else 0++ if revenue_change != 0:+ operating_leverage = operating_change / revenue_change++ leverage_interpretation = "High operating leverage - earnings sensitive to revenue changes" if abs(+ operating_leverage) > 2 else "Moderate operating leverage" if abs(+ operating_leverage) > 1 else "Low operating leverage"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Operating Leverage",+ value=operating_leverage,+ interpretation=leverage_interpretation,+ risk_level=RiskLevel.HIGH if abs(operating_leverage) > 3 else RiskLevel.MODERATE,+ methodology="% Change in Operating Income / % Change in Revenue",+ limitations=["Single period calculation may not reflect long-term leverage"]+ ))++ # Expense ratios analysis+ if revenue > 0:+ # R&D Intensity+ rd_expenses = income.get('rd_expenses', 0)+ if rd_expenses > 0:+ rd_intensity = self.safe_divide(rd_expenses, revenue)+ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="R&D Intensity",+ value=rd_intensity,+ interpretation=f"R&D spending represents {self.format_percentage(rd_intensity)} of revenue, indicating {'high' if rd_intensity > 0.05 else 'moderate' if rd_intensity > 0.02 else 'low'} innovation investment",+ risk_level=RiskLevel.LOW,+ methodology="R&D Expenses / Revenue"+ ))++ # SG&A Efficiency+ selling_expenses = income.get('selling_expenses', 0)+ admin_expenses = income.get('administrative_expenses', 0)+ sga_total = selling_expenses + admin_expenses++ if sga_total > 0:+ sga_ratio = self.safe_divide(sga_total, revenue)+ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name="SG&A Ratio",+ value=sga_ratio,+ interpretation=f"SG&A expenses represent {self.format_percentage(sga_ratio)} of revenue",+ risk_level=RiskLevel.HIGH if sga_ratio > 0.3 else RiskLevel.MODERATE if sga_ratio > 0.2 else RiskLevel.LOW,+ methodology="(Selling + General & Administrative Expenses) / Revenue"+ ))++ return results++ def _analyze_earnings_per_share(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Comprehensive EPS analysis including basic, diluted, and quality assessment"""+ results = []+ income = statements.income_statement++ # Extract EPS data+ basic_eps = income.get('basic_eps')+ diluted_eps = income.get('diluted_eps')+ basic_shares = income.get('shares_outstanding_basic')+ diluted_shares = income.get('shares_outstanding_diluted')+ net_income = income.get('net_income', 0)++ # Calculate EPS if not provided+ if not basic_eps and basic_shares and basic_shares > 0:+ basic_eps = self.safe_divide(net_income, basic_shares)++ if not diluted_eps and diluted_shares and diluted_shares > 0:+ diluted_eps = self.safe_divide(net_income, diluted_shares)++ if basic_eps is not None:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Basic EPS",+ value=basic_eps,+ interpretation=f"Basic earnings per share of ${basic_eps:.2f}",+ risk_level=RiskLevel.LOW if basic_eps > 0 else RiskLevel.HIGH,+ methodology="Net Income / Weighted Average Basic Shares Outstanding"+ ))++ if diluted_eps is not None:+ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="Diluted EPS",+ value=diluted_eps,+ interpretation=f"Diluted earnings per share of ${diluted_eps:.2f}",+ risk_level=RiskLevel.LOW if diluted_eps > 0 else RiskLevel.HIGH,+ methodology="Net Income (adjusted for dilutive securities) / Weighted Average Diluted Shares Outstanding"+ ))++ # Dilution analysis+ if basic_eps and diluted_eps and basic_eps != 0:+ dilution_effect = (basic_eps - diluted_eps) / basic_eps++ if dilution_effect > 0.05:+ dilution_interpretation = "Significant dilution from potential securities conversions"+ dilution_risk = RiskLevel.MODERATE+ elif dilution_effect > 0.02:+ dilution_interpretation = "Moderate dilution from potential securities conversions"+ dilution_risk = RiskLevel.LOW+ else:+ dilution_interpretation = "Minimal dilution from potential securities conversions"+ dilution_risk = RiskLevel.LOW++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="EPS Dilution Effect",+ value=dilution_effect,+ interpretation=dilution_interpretation,+ risk_level=dilution_risk,+ methodology="(Basic EPS - Diluted EPS) / Basic EPS"+ ))++ # EPS growth analysis+ if comparative_data and basic_eps is not None:+ eps_values = []+ periods = []++ # Collect historical EPS+ for i, past_statements in enumerate(comparative_data):+ past_eps = past_statements.income_statement.get('basic_eps')+ if past_eps is not None:+ eps_values.append(past_eps)+ periods.append(f"Period-{len(comparative_data) - i}")++ eps_values.append(basic_eps)+ periods.append("Current")++ if len(eps_values) > 1:+ eps_trend = self.calculate_trend(eps_values, periods)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.PROFITABILITY,+ metric_name="EPS Growth Trend",+ value=eps_trend.growth_rate or 0,+ interpretation=eps_trend.trend_analysis,+ risk_level=RiskLevel.LOW if eps_trend.growth_rate and eps_trend.growth_rate > 0 else RiskLevel.HIGH,+ methodology="Compound Annual Growth Rate of Basic EPS"+ ))++ return results++ def _analyze_non_recurring_items(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Analyze non-recurring and unusual items"""+ results = []+ income = statements.income_statement++ # Identify non-recurring items+ non_recurring_items = {+ 'discontinued_operations': income.get('discontinued_operations', 0),+ 'extraordinary_items': income.get('extraordinary_items', 0),+ 'restructuring_charges': income.get('restructuring_charges', 0),+ 'impairment_losses': income.get('impairment_losses', 0),+ 'gains_losses_disposals': income.get('gains_losses_disposals', 0)+ }++ total_non_recurring = sum(abs(value) for value in non_recurring_items.values())+ net_income = income.get('net_income', 0)++ if total_non_recurring > 0:+ # Impact on earnings+ if net_income != 0:+ non_recurring_impact = total_non_recurring / abs(net_income)++ impact_interpretation = "Significant non-recurring items affecting earnings comparability" if non_recurring_impact > 0.1 else "Moderate non-recurring items impact" if non_recurring_impact > 0.05 else "Minor non-recurring items impact"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Non-Recurring Items Impact",+ value=non_recurring_impact,+ interpretation=impact_interpretation,+ risk_level=RiskLevel.HIGH if non_recurring_impact > 0.2 else RiskLevel.MODERATE if non_recurring_impact > 0.1 else RiskLevel.LOW,+ methodology="Total Non-Recurring Items / |Net Income|",+ limitations=["Adjustment may be needed for normalized earnings analysis"]+ ))++ # Frequency analysis+ if comparative_data:+ historical_non_recurring = []+ for past_statements in comparative_data:+ past_income = past_statements.income_statement+ past_non_recurring = sum(abs(past_income.get(item, 0)) for item in non_recurring_items.keys())+ historical_non_recurring.append(past_non_recurring)++ non_recurring_frequency = sum(1 for x in historical_non_recurring if x > 0) / len(+ historical_non_recurring)++ frequency_interpretation = "Frequent non-recurring items - may indicate operational issues" if non_recurring_frequency > 0.5 else "Occasional non-recurring items" if non_recurring_frequency > 0.2 else "Rare non-recurring items"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Non-Recurring Items Frequency",+ value=non_recurring_frequency,+ interpretation=frequency_interpretation,+ risk_level=RiskLevel.HIGH if non_recurring_frequency > 0.6 else RiskLevel.MODERATE if non_recurring_frequency > 0.3 else RiskLevel.LOW,+ methodology="Number of periods with non-recurring items / Total periods"+ ))++ return results++ def _assess_income_quality(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[AnalysisResult]:+ """Comprehensive income quality assessment"""+ results = []++ # Earnings persistence analysis+ if comparative_data and len(comparative_data) >= 2:+ net_incomes = []+ for past_statements in comparative_data:+ past_income = past_statements.income_statement.get('net_income', 0)+ net_incomes.append(past_income)++ current_income = statements.income_statement.get('net_income', 0)+ net_incomes.append(current_income)++ # Calculate earnings volatility+ if len(net_incomes) > 1:+ mean_income = np.mean(net_incomes)+ std_income = np.std(net_incomes)+ earnings_volatility = std_income / abs(mean_income) if mean_income != 0 else 0++ volatility_interpretation = "High earnings volatility - low predictability" if earnings_volatility > 0.3 else "Moderate earnings volatility" if earnings_volatility > 0.15 else "Low earnings volatility - stable earnings"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Earnings Volatility",+ value=earnings_volatility,+ interpretation=volatility_interpretation,+ risk_level=RiskLevel.HIGH if earnings_volatility > 0.4 else RiskLevel.MODERATE if earnings_volatility > 0.2 else RiskLevel.LOW,+ methodology="Standard Deviation of Net Income / |Mean Net Income|"+ ))++ # Accruals quality (if cash flow data available)+ cash_flow = statements.cash_flow+ operating_cash_flow = cash_flow.get('operating_cash_flow')+ net_income = statements.income_statement.get('net_income', 0)++ if operating_cash_flow is not None and net_income != 0:+ accruals_ratio = abs(net_income - operating_cash_flow) / abs(net_income)++ accruals_interpretation = "High accruals - potential earnings manipulation risk" if accruals_ratio > 0.2 else "Moderate accruals level" if accruals_ratio > 0.1 else "Low accruals - high earnings quality"++ results.append(AnalysisResult(+ analysis_type=AnalysisType.QUALITY,+ metric_name="Accruals Ratio",+ value=accruals_ratio,+ interpretation=accruals_interpretation,+ risk_level=RiskLevel.HIGH if accruals_ratio > 0.3 else RiskLevel.MODERATE if accruals_ratio > 0.15 else RiskLevel.LOW,+ methodology="|Net Income - Operating Cash Flow| / |Net Income|",+ limitations=["High accruals may be justified by business model or growth phase"]+ ))++ return results++ def _perform_common_size_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[+ AnalysisResult]:+ """Perform common-size income statement analysis"""+ results = []+ income = statements.income_statement+ revenue = income.get('revenue', 0)++ if revenue == 0:+ return results++ # Calculate common-size percentages for key items+ common_size_items = {+ 'Cost of Sales': income.get('cost_of_sales', 0),+ 'Operating Expenses': income.get('operating_expenses', 0),+ 'Interest Expense': income.get('interest_expense', 0),+ 'Tax Expense': income.get('tax_expense', 0)+ }++ for item_name, item_value in common_size_items.items():+ if item_value != 0:+ common_size_pct = self.safe_divide(item_value, revenue)++ results.append(AnalysisResult(+ analysis_type=AnalysisType.ACTIVITY,+ metric_name=f"{item_name} as % of Revenue",+ value=common_size_pct,+ interpretation=f"{item_name} represents {self.format_percentage(common_size_pct)} of total revenue",+ risk_level=RiskLevel.LOW,+ methodology=f"{item_name} / Revenue"+ ))++ return results++ def _calculate_ebitda(self, statements: FinancialStatements) -> Optional[float]:+ """Calculate EBITDA from available data"""+ income = statements.income_statement++ operating_income = income.get('operating_income')+ depreciation = income.get('depreciation', 0)+ amortization = income.get('amortization', 0)++ if operating_income is not None:+ return operating_income + depreciation + amortization++ return None++ def _identify_revenue_quality_issues(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> List[str]:+ """Identify potential revenue quality and manipulation issues"""+ quality_issues = []++ income = statements.income_statement+ balance_sheet = statements.balance_sheet++ revenue = income.get('revenue', 0)+ accounts_receivable = balance_sheet.get('accounts_receivable', 0)++ # Red flag: Accounts receivable growing faster than revenue+ if comparative_data and len(comparative_data) > 0:+ prev_statements = comparative_data[-1]+ prev_revenue = prev_statements.income_statement.get('revenue', 0)+ prev_receivables = prev_statements.balance_sheet.get('accounts_receivable', 0)++ if prev_revenue > 0 and prev_receivables > 0:+ revenue_growth = (revenue / prev_revenue) - 1 if prev_revenue > 0 else 0+ receivables_growth = (accounts_receivable / prev_receivables) - 1 if prev_receivables > 0 else 0++ if receivables_growth > revenue_growth + 0.1: # 10% threshold+ quality_issues.append("Accounts receivable growing significantly faster than revenue")++ # Red flag: Very high Days Sales Outstanding+ if revenue > 0 and accounts_receivable > 0:+ dso = (accounts_receivable / revenue) * 365+ if dso > 120: # Industry-dependent threshold+ quality_issues.append(f"Very high Days Sales Outstanding ({dso:.0f} days)")++ # Red flag: Revenue recognition timing issues (quarter-end spikes)+ # This would require quarterly data to detect properly++ # Red flag: Related party transactions (would need notes data)+ notes = statements.notes+ if any('related_party' in key.lower() for key in notes.keys()):+ quality_issues.append("Related party revenue transactions require scrutiny")++ return quality_issues++ def get_key_metrics(self, statements: FinancialStatements) -> Dict[str, float]:+ """Return key income statement metrics"""+ income = statements.income_statement+ revenue = income.get('revenue', 0)++ metrics = {}++ if revenue > 0:+ metrics['gross_profit_margin'] = self.safe_divide(+ revenue - income.get('cost_of_sales', 0), revenue)+ metrics['operating_profit_margin'] = self.safe_divide(+ income.get('operating_income', 0), revenue)+ metrics['net_profit_margin'] = self.safe_divide(+ income.get('net_income', 0), revenue)++ ebitda = self._calculate_ebitda(statements)+ if ebitda is not None:+ metrics['ebitda_margin'] = self.safe_divide(ebitda, revenue)++ metrics['basic_eps'] = income.get('basic_eps', 0)+ metrics['diluted_eps'] = income.get('diluted_eps', 0)++ # Tax rate+ pretax_income = income.get('pretax_income', 0)+ tax_expense = income.get('tax_expense', 0)+ if pretax_income != 0:+ metrics['effective_tax_rate'] = self.safe_divide(tax_expense, pretax_income)++ return metrics++ def create_eps_analysis(self, statements: FinancialStatements,+ comparative_data: Optional[List[FinancialStatements]] = None) -> EPSAnalysis:+ """Create comprehensive EPS analysis object"""+ income = statements.income_statement++ basic_eps = income.get('basic_eps', 0)+ diluted_eps = income.get('diluted_eps', 0)+ basic_shares = income.get('shares_outstanding_basic', 0)+ diluted_shares = income.get('shares_outstanding_diluted', 0)++ # Calculate dilution effect+ dilution_effect = 0+ if basic_eps != 0 and diluted_eps != 0:+ dilution_effect = (basic_eps - diluted_eps) / basic_eps++ # Assess EPS quality+ eps_quality = IncomeQualityIndicator.HIGH_QUALITY+ if dilution_effect > 0.1:+ eps_quality = IncomeQualityIndicator.MODERATE_QUALITY++ # Check for antidilutive securities+ antidilutive_securities = diluted_shares < basic_shares if basic_shares > 0 else False++ # Calculate EPS growth and volatility if historical data available+ eps_growth_rate = None+ eps_volatility = None++ if comparative_data and len(comparative_data) > 0:+ eps_values = []+ for past_statements in comparative_data:+ past_eps = past_statements.income_statement.get('basic_eps')+ if past_eps is not None:+ eps_values.append(past_eps)++ if eps_values and basic_eps is not None:+ eps_values.append(basic_eps)++ if len(eps_values) > 1:+ # Growth rate calculation+ if eps_values[0] != 0:+ if len(eps_values) == 2:+ eps_growth_rate = (eps_values[-1] / eps_values[0]) - 1+ else:+ n_periods = len(eps_values) - 1+ eps_growth_rate = (eps_values[-1] / eps_values[0]) ** (1 / n_periods) - 1++ # Volatility calculation+ mean_eps = np.mean(eps_values)+ std_eps = np.std(eps_values)+ eps_volatility = std_eps / abs(mean_eps) if mean_eps != 0 else 0++ return EPSAnalysis(+ basic_eps=basic_eps,+ diluted_eps=diluted_eps,+ basic_shares=basic_shares,+ diluted_shares=diluted_shares,+ dilution_effect=dilution_effect,+ eps_quality=eps_quality,+ antidilutive_securities=antidilutive_securities,+ eps_growth_rate=eps_growth_rate,+ eps_volatility=eps_volatility+ )++ def analyze_non_recurring_items(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> NonRecurringItemsAnalysis:+ """Create detailed non-recurring items analysis"""+ income = statements.income_statement++ # Extract non-recurring items+ discontinued_operations = income.get('discontinued_operations', 0)+ unusual_items = income.get('unusual_items', 0)+ extraordinary_items = income.get('extraordinary_items', 0)+ restructuring_charges = income.get('restructuring_charges', 0)+ impairment_losses = income.get('impairment_losses', 0)+ gains_losses_disposals = income.get('gains_losses_disposals', 0)++ total_non_recurring = sum(abs(x) for x in [+ discontinued_operations, unusual_items, extraordinary_items,+ restructuring_charges, impairment_losses, gains_losses_disposals+ ])++ # Calculate impact on core earnings+ net_income = income.get('net_income', 0)+ impact_on_core_earnings = total_non_recurring / abs(net_income) if net_income != 0 else 0++ # Frequency analysis+ frequency_analysis = "Single period analysis"+ persistence_assessment = "Cannot assess without historical data"++ if comparative_data:+ periods_with_non_recurring = 0+ total_periods = len(comparative_data) + 1++ for past_statements in comparative_data:+ past_income = past_statements.income_statement+ past_non_recurring = sum(abs(past_income.get(item, 0)) for item in [+ 'discontinued_operations', 'unusual_items', 'extraordinary_items',+ 'restructuring_charges', 'impairment_losses', 'gains_losses_disposals'+ ])+ if past_non_recurring > 0:+ periods_with_non_recurring += 1++ if total_non_recurring > 0:+ periods_with_non_recurring += 1++ frequency_rate = periods_with_non_recurring / total_periods++ if frequency_rate > 0.6:+ frequency_analysis = "Frequent non-recurring items - may indicate operational issues"+ persistence_assessment = "High persistence - items may be recurring in nature"+ elif frequency_rate > 0.3:+ frequency_analysis = "Occasional non-recurring items"+ persistence_assessment = "Moderate persistence"+ else:+ frequency_analysis = "Rare non-recurring items"+ persistence_assessment = "Low persistence - truly non-recurring"++ return NonRecurringItemsAnalysis(+ total_non_recurring=total_non_recurring,+ discontinued_operations=discontinued_operations,+ unusual_items=unusual_items,+ extraordinary_items=extraordinary_items,+ restructuring_charges=restructuring_charges,+ impairment_losses=impairment_losses,+ gains_losses_disposals=gains_losses_disposals,+ impact_on_core_earnings=impact_on_core_earnings,+ frequency_analysis=frequency_analysis,+ persistence_assessment=persistence_assessment+ )++ def assess_revenue_quality(self, statements: FinancialStatements,+ comparative_data: Optional[+ List[FinancialStatements]] = None) -> RevenueQualityAssessment:+ """Comprehensive revenue quality assessment"""+ income = statements.income_statement+ balance_sheet = statements.balance_sheet++ revenue = income.get('revenue', 0)+ accounts_receivable = balance_sheet.get('accounts_receivable', 0)++ # Initialize metrics+ revenue_growth_rate = 0+ revenue_volatility = 0+ seasonality_factor = 0+ revenue_concentration = 0 # Would need segment data+ days_sales_outstanding = 0++ # Calculate DSO+ if revenue > 0 and accounts_receivable >= 0:+ days_sales_outstanding = (accounts_receivable / revenue) * 365++ # Calculate growth and volatility if historical data available+ if comparative_data and len(comparative_data) > 0:+ revenue_values = []+ for past_statements in comparative_data:+ past_revenue = past_statements.income_statement.get('revenue', 0)+ revenue_values.append(past_revenue)++ revenue_values.append(revenue)++ if len(revenue_values) > 1:+ # Growth rate+ if revenue_values[0] > 0:+ if len(revenue_values) == 2:+ revenue_growth_rate = (revenue_values[-1] / revenue_values[0]) - 1+ else:+ n_periods = len(revenue_values) - 1+ revenue_growth_rate = (revenue_values[-1] / revenue_values[0]) ** (1 / n_periods) - 1++ # Volatility+ mean_revenue = np.mean(revenue_values)+ std_revenue = np.std(revenue_values)+ revenue_volatility = std_revenue / mean_revenue if mean_revenue > 0 else 0++ # Quality indicators+ quality_indicators = []+ recognition_issues = []++ if days_sales_outstanding <= 45:+ quality_indicators.append("Healthy collection period")+ elif days_sales_outstanding > 90:+ recognition_issues.append("Extended collection period may indicate quality issues")++ if revenue_growth_rate > 0:+ quality_indicators.append("Positive revenue growth")+ elif revenue_growth_rate < -0.1:+ recognition_issues.append("Significant revenue decline")++ if revenue_volatility < 0.1:+ quality_indicators.append("Stable revenue pattern")+ elif revenue_volatility > 0.3:+ recognition_issues.append("High revenue volatility")++ # Calculate overall quality score+ quality_score = 100+ quality_score -= len(recognition_issues) * 20+ quality_score -= max(0, (days_sales_outstanding - 45) / 10 * 5) # Penalize high DSO+ quality_score -= max(0, revenue_volatility * 100) # Penalize volatility+ quality_score = max(0, min(100, quality_score))++ return RevenueQualityAssessment(+ revenue_growth_rate=revenue_growth_rate,+ revenue_volatility=revenue_volatility,+ seasonality_factor=seasonality_factor,+ revenue_concentration=revenue_concentration,+ days_sales_outstanding=days_sales_outstanding,+ revenue_quality_score=quality_score,+ recognition_issues=recognition_issues,+ quality_indicators=quality_indicators+ )\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/tree b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/treenew file mode 100644index 000000000..f5bc40270--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/tree@@ -0,0 +1,34 @@+financial_analysis/+├── __init__.py+├── core/+│ ├── __init__.py+│ ├── data_processor.py+│ └── base_analyzer.py+├── statement_analyzers/+│ ├── __init__.py+│ ├── income_statement.py # Revenue/expense recognition, EPS, non-recurring items+│ ├── balance_sheet.py # Assets, liabilities, equity, common-size analysis+│ ├── cash_flow.py # Direct/indirect, IFRS vs GAAP, FCF+│ └── comprehensive_analyzer.py # Multi-statement integration+├── specialized_analysis/+│ ├── __init__.py+│ ├── inventory_analysis.py # Lower of cost/NRV, inflation effects+│ ├── asset_analysis.py # PPE, intangibles, impairment, leases+│ ├── tax_analysis.py # Deferred tax, effective vs statutory rates+│ ├── quality_analysis.py # Earnings quality, manipulation detection+│ ├── intercorporate_investments.py # Business combinations, associates, SPEs+│ ├── employee_compensation.py # Post-employment benefits, share-based comp+│ ├── multinational_operations.py # Currency translation, hyperinflation+│ └── financial_institutions.py # CAMELS, bank/insurance analysis+├── financial_modeling/+│ ├── __init__.py+│ ├── ratio_calculator.py # All ratios: activity, liquidity, solvency, profitability+│ ├── dupont_analysis.py # ROE decomposition+│ └── forecasting_models.py # Pro forma, Porter's 5 forces, sales forecasting+├── reporting/+│ ├── __init__.py+│ └── report_generator.py+└── utils/+ ├── __init__.py+ ├── validators.py+ └── constants.py\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/cds_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/cds_analytics.pynew file mode 100644index 000000000..0bba459b9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/cds_analytics.py@@ -0,0 +1,29 @@++Fixed Income Cds Analytics Module+=================================++Credit default swap analysis and pricing++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/config.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/config.pynew file mode 100644index 000000000..2b17716eb--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/config.py@@ -0,0 +1,341 @@++Fixed Income Config Module+=================================++Portfolio management configuration++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from enum import Enum+from decimal import Decimal, getcontext+from typing import Dict, List, Optional, Union+import datetime++# Set high precision for financial calculations+getcontext().prec = 28+++class DayCountConvention(Enum):+ """Day count conventions used in fixed income markets"""+ ACTUAL_360 = "Actual/360"+ ACTUAL_365 = "Actual/365"+ ACTUAL_ACTUAL = "Actual/Actual"+ THIRTY_360 = "30/360"+ THIRTY_360_EUROPEAN = "30E/360"+ ACTUAL_365_FIXED = "Actual/365 Fixed"+ NL_365 = "NL/365"+++class CompoundingFrequency(Enum):+ """Compounding frequency conventions"""+ CONTINUOUS = 0+ ANNUAL = 1+ SEMI_ANNUAL = 2+ QUARTERLY = 4+ MONTHLY = 12+ DAILY = 365+++class BusinessDayConvention(Enum):+ """Business day adjustment conventions"""+ FOLLOWING = "Following"+ MODIFIED_FOLLOWING = "Modified Following"+ PRECEDING = "Preceding"+ MODIFIED_PRECEDING = "Modified Preceding"+ UNADJUSTED = "Unadjusted"+++class Currency(Enum):+ """Major currencies for fixed income markets"""+ USD = "USD"+ EUR = "EUR"+ GBP = "GBP"+ JPY = "JPY"+ CHF = "CHF"+ CAD = "CAD"+ AUD = "AUD"+ CNY = "CNY"+++class CreditRating(Enum):+ """Standard credit rating scale (S&P equivalent)"""+ AAA = "AAA"+ AA_PLUS = "AA+"+ AA = "AA"+ AA_MINUS = "AA-"+ A_PLUS = "A+"+ A = "A"+ A_MINUS = "A-"+ BBB_PLUS = "BBB+"+ BBB = "BBB"+ BBB_MINUS = "BBB-"+ BB_PLUS = "BB+"+ BB = "BB"+ BB_MINUS = "BB-"+ B_PLUS = "B+"+ B = "B"+ B_MINUS = "B-"+ CCC_PLUS = "CCC+"+ CCC = "CCC"+ CCC_MINUS = "CCC-"+ CC = "CC"+ C = "C"+ D = "D"+++class BondType(Enum):+ """Bond instrument types"""+ FIXED_RATE = "Fixed Rate"+ FLOATING_RATE = "Floating Rate"+ ZERO_COUPON = "Zero Coupon"+ CALLABLE = "Callable"+ PUTABLE = "Putable"+ CONVERTIBLE = "Convertible"+ INFLATION_LINKED = "Inflation Linked"+ PERPETUAL = "Perpetual"+++class SecuritizationType(Enum):+ """Securitized product types"""+ MORTGAGE_PASS_THROUGH = "Mortgage Pass-Through"+ CMO = "Collateralized Mortgage Obligation"+ ABS = "Asset-Backed Security"+ CDO = "Collateralized Debt Obligation"+ COVERED_BOND = "Covered Bond"+++# Market Conventions by Currency+MARKET_CONVENTIONS = {+ Currency.USD: {+ 'day_count': DayCountConvention.THIRTY_360,+ 'settlement_days': 3,+ 'compounding': CompoundingFrequency.SEMI_ANNUAL,+ 'business_day_convention': BusinessDayConvention.MODIFIED_FOLLOWING+ },+ Currency.EUR: {+ 'day_count': DayCountConvention.ACTUAL_ACTUAL,+ 'settlement_days': 3,+ 'compounding': CompoundingFrequency.ANNUAL,+ 'business_day_convention': BusinessDayConvention.MODIFIED_FOLLOWING+ },+ Currency.GBP: {+ 'day_count': DayCountConvention.ACTUAL_365,+ 'settlement_days': 3,+ 'compounding': CompoundingFrequency.SEMI_ANNUAL,+ 'business_day_convention': BusinessDayConvention.MODIFIED_FOLLOWING+ },+ Currency.JPY: {+ 'day_count': DayCountConvention.ACTUAL_365,+ 'settlement_days': 3,+ 'compounding': CompoundingFrequency.SEMI_ANNUAL,+ 'business_day_convention': BusinessDayConvention.MODIFIED_FOLLOWING+ }+}++# Numerical Precision Settings+PRECISION_CONFIG = {+ 'decimal_places': 8,+ 'price_precision': 6,+ 'yield_precision': 4,+ 'spread_precision': 1,+ 'duration_precision': 4,+ 'convergence_tolerance': Decimal('1e-10'),+ 'max_iterations': 1000+}++# Default Calculation Parameters+DEFAULT_PARAMS = {+ 'yield_calculation_method': 'newton_raphson',+ 'interpolation_method': 'cubic_spline',+ 'volatility_model': 'black_scholes',+ 'credit_model': 'merton',+ 'monte_carlo_paths': 10000,+ 'binomial_steps': 100+}++# Credit Rating Numerical Mapping (for calculations)+RATING_SCORES = {+ CreditRating.AAA: 1,+ CreditRating.AA_PLUS: 2,+ CreditRating.AA: 3,+ CreditRating.AA_MINUS: 4,+ CreditRating.A_PLUS: 5,+ CreditRating.A: 6,+ CreditRating.A_MINUS: 7,+ CreditRating.BBB_PLUS: 8,+ CreditRating.BBB: 9,+ CreditRating.BBB_MINUS: 10,+ CreditRating.BB_PLUS: 11,+ CreditRating.BB: 12,+ CreditRating.BB_MINUS: 13,+ CreditRating.B_PLUS: 14,+ CreditRating.B: 15,+ CreditRating.B_MINUS: 16,+ CreditRating.CCC_PLUS: 17,+ CreditRating.CCC: 18,+ CreditRating.CCC_MINUS: 19,+ CreditRating.CC: 20,+ CreditRating.C: 21,+ CreditRating.D: 22+}++# Investment Grade Threshold+INVESTMENT_GRADE_THRESHOLD = RATING_SCORES[CreditRating.BBB_MINUS]++# Standard Treasury Maturities (in years)+TREASURY_MATURITIES = [+ Decimal('0.25'), # 3 months+ Decimal('0.5'), # 6 months+ Decimal('1'), # 1 year+ Decimal('2'), # 2 years+ Decimal('3'), # 3 years+ Decimal('5'), # 5 years+ Decimal('7'), # 7 years+ Decimal('10'), # 10 years+ Decimal('20'), # 20 years+ Decimal('30') # 30 years+]++# Swap Curve Standard Tenors+SWAP_TENORS = [+ '1M', '3M', '6M', '1Y', '2Y', '3Y', '4Y', '5Y',+ '7Y', '10Y', '12Y', '15Y', '20Y', '25Y', '30Y'+]++# Credit Default Swap Standard Tenors+CDS_TENORS = ['6M', '1Y', '2Y', '3Y', '4Y', '5Y', '7Y', '10Y']++# Holidays (basic implementation - can be extended)+US_HOLIDAYS = [+ # New Year's Day, Martin Luther King Jr. Day, Presidents Day,+ # Memorial Day, Independence Day, Labor Day, Columbus Day,+ # Veterans Day, Thanksgiving, Christmas Day+]++# Data Provider Configuration+DATA_PROVIDERS = {+ 'bloomberg': {+ 'base_url': 'https://api.bloomberg.com',+ 'fields': ['PX_LAST', 'YLD_YTM_MID', 'DUR_ADJ_MID'],+ 'rate_limit': 1000 # requests per hour+ },+ 'refinitiv': {+ 'base_url': 'https://api.refinitiv.com',+ 'fields': ['TR.PriceClose', 'TR.YieldToMaturity'],+ 'rate_limit': 500+ },+ 'fred': {+ 'base_url': 'https://api.stlouisfed.org/fred',+ 'series': ['DGS1MO', 'DGS3MO', 'DGS6MO', 'DGS1', 'DGS2', 'DGS5', 'DGS10', 'DGS30'],+ 'rate_limit': 120+ },+ 'yahoo': {+ 'base_url': 'https://query1.finance.yahoo.com',+ 'rate_limit': 2000+ }+}++# Error Tolerance Levels+ERROR_TOLERANCE = {+ 'low': Decimal('1e-6'),+ 'medium': Decimal('1e-8'),+ 'high': Decimal('1e-10'),+ 'ultra_high': Decimal('1e-12')+}++# Validation Rules+VALIDATION_RULES = {+ 'min_yield': Decimal('-0.10'), # -10% minimum yield+ 'max_yield': Decimal('1.00'), # 100% maximum yield+ 'min_price': Decimal('0.01'), # Minimum bond price+ 'max_price': Decimal('10.00'), # Maximum bond price (1000%)+ 'min_maturity_days': 1,+ 'max_maturity_years': 100,+ 'min_coupon_rate': Decimal('0.00'),+ 'max_coupon_rate': Decimal('1.00')+}++# Model Parameters+MODEL_PARAMS = {+ 'black_scholes': {+ 'risk_free_rate': Decimal('0.02'),+ 'volatility': Decimal('0.20')+ },+ 'vasicek': {+ 'mean_reversion_speed': Decimal('0.1'),+ 'long_term_mean': Decimal('0.05'),+ 'volatility': Decimal('0.01')+ },+ 'hull_white': {+ 'mean_reversion_speed': Decimal('0.1'),+ 'volatility': Decimal('0.01')+ }+}+++def get_market_convention(currency: Currency) -> Dict:+ """Get market conventions for a specific currency"""+ return MARKET_CONVENTIONS.get(currency, MARKET_CONVENTIONS[Currency.USD])+++def is_investment_grade(rating: CreditRating) -> bool:+ """Check if a credit rating is investment grade"""+ return RATING_SCORES[rating] <= INVESTMENT_GRADE_THRESHOLD+++def get_precision(calc_type: str) -> int:+ """Get precision for specific calculation type"""+ precision_map = {+ 'price': PRECISION_CONFIG['price_precision'],+ 'yield': PRECISION_CONFIG['yield_precision'],+ 'spread': PRECISION_CONFIG['spread_precision'],+ 'duration': PRECISION_CONFIG['duration_precision']+ }+ return precision_map.get(calc_type, PRECISION_CONFIG['decimal_places'])+++def get_tolerance(level: str = 'medium') -> Decimal:+ """Get error tolerance for calculations"""+ return ERROR_TOLERANCE.get(level, ERROR_TOLERANCE['medium'])+++class ConfigurationError(Exception):+ """Custom exception for configuration errors"""+ pass+++def validate_configuration():+ """Validate configuration settings on module load"""+ if getcontext().prec < 20:+ raise ConfigurationError("Decimal precision too low for financial calculations")++ # Validate that all required configurations are present+ required_configs = ['MARKET_CONVENTIONS', 'PRECISION_CONFIG', 'DEFAULT_PARAMS']+ for config in required_configs:+ if config not in globals():+ raise ConfigurationError(f"Missing required configuration: {config}")+++# Run validation on import+validate_configuration()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/credit_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/credit_analytics.pynew file mode 100644index 000000000..840c1ac32--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/credit_analytics.py@@ -0,0 +1,29 @@++Fixed Income Credit Analytics Module+=================================++Credit risk analysis and assessment++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/government_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/government_analysis.pynew file mode 100644index 000000000..61f1f12ad--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/government_analysis.py@@ -0,0 +1,675 @@++Fixed Income Government Analysis Module+=================================++Government securities analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Dict, Optional, Tuple+from decimal import Decimal+from datetime import date+from models import Bond, Portfolio+from credit_analytics import CreditRiskMeasures, ProbabilityOfDefault+from utils import ValidationUtils, cache_calculation+from config import Currency, CreditRating+from yield_curves import SpotCurve+from valuation import BondValuation+++class SovereignCreditAnalysis:+ """Sovereign credit risk analysis and evaluation"""++ @staticmethod+ def sovereign_credit_factors() -> Dict[str, List[str]]:+ """Key factors for sovereign credit analysis"""+ return {+ 'economic_factors': [+ 'GDP growth rate',+ 'GDP per capita',+ 'Economic diversification',+ 'Competitiveness',+ 'Labor market flexibility',+ 'Monetary policy credibility'+ ],+ 'fiscal_factors': [+ 'Government debt/GDP ratio',+ 'Fiscal balance',+ 'Interest burden',+ 'Contingent liabilities',+ 'Fiscal flexibility',+ 'Revenue diversification'+ ],+ 'external_factors': [+ 'Current account balance',+ 'External debt',+ 'Foreign exchange reserves',+ 'Exchange rate regime',+ 'Export concentration',+ 'Capital market access'+ ],+ 'political_institutional': [+ 'Political stability',+ 'Institutional quality',+ 'Government effectiveness',+ 'Rule of law',+ 'Corruption control',+ 'Policy predictability'+ ]+ }++ @staticmethod+ def debt_sustainability_analysis(country_data: Dict[str, Decimal]) -> Dict[str, Decimal]:+ """Analyze sovereign debt sustainability"""+ # Extract key metrics+ debt_gdp = country_data.get('debt_to_gdp', Decimal('0.6'))+ gdp_growth = country_data.get('gdp_growth', Decimal('0.02'))+ interest_rate = country_data.get('avg_interest_rate', Decimal('0.03'))+ primary_balance = country_data.get('primary_balance_gdp', Decimal('0'))++ ValidationUtils.validate_percentage(debt_gdp, "Debt-to-GDP ratio", allow_negative=False)+ ValidationUtils.validate_percentage(gdp_growth, "GDP growth", allow_negative=True)+ ValidationUtils.validate_yield(interest_rate, "Average interest rate")+ ValidationUtils.validate_percentage(primary_balance, "Primary balance", allow_negative=True)++ # Debt dynamics: Δd = (r-g)d + primary_deficit+ # where d = debt/GDP, r = interest rate, g = growth rate++ real_interest_rate = interest_rate - gdp_growth+ debt_stabilizing_balance = -real_interest_rate * debt_gdp++ # Current debt change+ current_debt_change = real_interest_rate * debt_gdp - primary_balance++ # Projected debt/GDP in 5 years (simplified)+ projected_debt_gdp = debt_gdp+ for year in range(5):+ debt_change = real_interest_rate * projected_debt_gdp - primary_balance+ projected_debt_gdp += debt_change++ # Sustainability indicators+ sustainability_score = SovereignCreditAnalysis._calculate_sustainability_score(+ debt_gdp, gdp_growth, interest_rate, primary_balance+ )++ return {+ 'current_debt_gdp': debt_gdp,+ 'debt_stabilizing_balance': debt_stabilizing_balance,+ 'current_primary_balance': primary_balance,+ 'balance_gap': primary_balance - debt_stabilizing_balance,+ 'current_debt_change': current_debt_change,+ 'projected_debt_gdp_5y': projected_debt_gdp,+ 'sustainability_score': sustainability_score,+ 'fiscal_space': max(Decimal('0'), Decimal('0.9') - debt_gdp), # Assume 90% threshold+ 'sustainable': sustainability_score >= Decimal('0.7')+ }++ @staticmethod+ def _calculate_sustainability_score(debt_gdp: Decimal, gdp_growth: Decimal,+ interest_rate: Decimal, primary_balance: Decimal) -> Decimal:+ """Calculate composite sustainability score (0-1 scale)"""++ # Debt level score (lower is better)+ debt_score = max(Decimal('0'), Decimal('1') - debt_gdp / Decimal('1.5')) # Penalty above 150%++ # Growth score (higher is better)+ growth_score = min(Decimal('1'), max(Decimal('0'), gdp_growth * Decimal('10'))) # 10% = perfect++ # Interest burden score (lower is better)+ interest_score = max(Decimal('0'), Decimal('1') - interest_rate * Decimal('10')) # 10% = worst++ # Fiscal balance score (higher is better)+ balance_score = min(Decimal('1'), max(Decimal('0'), primary_balance * Decimal('20') + Decimal('0.5')))++ # Weighted average+ weights = [Decimal('0.3'), Decimal('0.25'), Decimal('0.25'), Decimal('0.2')]+ scores = [debt_score, growth_score, interest_score, balance_score]++ return sum(w * s for w, s in zip(weights, scores))++ @staticmethod+ def sovereign_spread_analysis(country: str, benchmark_yield: Decimal,+ sovereign_yield: Decimal, factors: Dict[str, Decimal]) -> Dict[str, Decimal]:+ """Analyze sovereign credit spreads"""+ ValidationUtils.validate_yield(benchmark_yield, "Benchmark yield")+ ValidationUtils.validate_yield(sovereign_yield, "Sovereign yield")++ # Basic spread calculation+ credit_spread = sovereign_yield - benchmark_yield+ spread_bps = credit_spread * Decimal('10000')++ # Factor decomposition (simplified)+ base_spread = Decimal('0.001') # 10 bps base++ # Economic factors contribution+ gdp_factor = factors.get('gdp_growth', Decimal('0.02'))+ economic_contrib = max(Decimal('0'), (Decimal('0.02') - gdp_factor) * Decimal('0.5'))++ # Fiscal factors contribution+ debt_gdp = factors.get('debt_gdp', Decimal('0.6'))+ fiscal_contrib = max(Decimal('0'), (debt_gdp - Decimal('0.6')) * Decimal('0.02'))++ # External factors contribution+ current_account = factors.get('current_account_gdp', Decimal('0'))+ external_contrib = max(Decimal('0'), -current_account * Decimal('0.1'))++ # Political/institutional factors+ political_score = factors.get('political_stability', Decimal('0.7')) # 0-1 scale+ political_contrib = max(Decimal('0'), (Decimal('0.7') - political_score) * Decimal('0.05'))++ theoretical_spread = base_spread + economic_contrib + fiscal_contrib + external_contrib + political_contrib++ return {+ 'observed_spread': credit_spread,+ 'spread_bps': spread_bps,+ 'theoretical_spread': theoretical_spread,+ 'spread_difference': credit_spread - theoretical_spread,+ 'factor_contributions': {+ 'base_spread': base_spread,+ 'economic_factor': economic_contrib,+ 'fiscal_factor': fiscal_contrib,+ 'external_factor': external_contrib,+ 'political_factor': political_contrib+ },+ 'relative_value': 'cheap' if credit_spread > theoretical_spread else 'expensive'+ }+++class MunicipalBondAnalysis:+ """Municipal bond analysis and evaluation"""++ @staticmethod+ def municipal_credit_factors() -> Dict[str, List[str]]:+ """Key factors for municipal credit analysis"""+ return {+ 'economic_base': [+ 'Economic diversity',+ 'Employment trends',+ 'Income levels',+ 'Population growth',+ 'Business environment',+ 'Tax base stability'+ ],+ 'financial_performance': [+ 'Operating performance',+ 'Debt burden',+ 'Liquidity position',+ 'Financial flexibility',+ 'Capital planning',+ 'Reserve levels'+ ],+ 'debt_structure': [+ 'Debt per capita',+ 'Debt service coverage',+ 'Direct vs overlapping debt',+ 'Variable rate exposure',+ 'Derivative usage',+ 'Refinancing risk'+ ],+ 'governance_management': [+ 'Management quality',+ 'Financial reporting',+ 'Budget practices',+ 'Transparency',+ 'Political environment',+ 'Stakeholder relations'+ ]+ }++ @staticmethod+ def go_bond_analysis(issuer_data: Dict[str, Decimal]) -> Dict[str, Decimal]:+ """Analyze General Obligation (GO) municipal bonds"""++ # Key GO bond metrics+ assessed_value = issuer_data.get('assessed_value', Decimal('1000000000')) # $1B default+ population = issuer_data.get('population', Decimal('100000')) # 100k default+ total_debt = issuer_data.get('total_debt', Decimal('50000000')) # $50M default+ annual_debt_service = issuer_data.get('annual_debt_service', Decimal('5000000')) # $5M default+ operating_revenues = issuer_data.get('operating_revenues', Decimal('100000000')) # $100M default+ fund_balance = issuer_data.get('fund_balance', Decimal('20000000')) # $20M default++ # Calculate key ratios+ debt_per_capita = total_debt / population+ debt_to_assessed_value = total_debt / assessed_value+ debt_service_coverage = operating_revenues / annual_debt_service+ fund_balance_ratio = fund_balance / operating_revenues++ # Credit quality scoring+ debt_burden_score = MunicipalBondAnalysis._score_debt_burden(debt_per_capita, debt_to_assessed_value)+ coverage_score = MunicipalBondAnalysis._score_coverage(debt_service_coverage)+ liquidity_score = MunicipalBondAnalysis._score_liquidity(fund_balance_ratio)++ overall_score = (debt_burden_score + coverage_score + liquidity_score) / Decimal('3')++ return {+ 'debt_per_capita': debt_per_capita,+ 'debt_to_assessed_value_pct': debt_to_assessed_value * Decimal('100'),+ 'debt_service_coverage': debt_service_coverage,+ 'fund_balance_ratio_pct': fund_balance_ratio * Decimal('100'),+ 'credit_scores': {+ 'debt_burden': debt_burden_score,+ 'coverage': coverage_score,+ 'liquidity': liquidity_score,+ 'overall': overall_score+ },+ 'credit_quality': MunicipalBondAnalysis._interpret_score(overall_score)+ }++ @staticmethod+ def revenue_bond_analysis(project_data: Dict[str, Decimal]) -> Dict[str, Decimal]:+ """Analyze Revenue municipal bonds"""++ # Revenue bond specific metrics+ gross_revenues = project_data.get('gross_revenues', Decimal('50000000'))+ operating_expenses = project_data.get('operating_expenses', Decimal('30000000'))+ debt_service = project_data.get('debt_service', Decimal('15000000'))+ rate_covenant = project_data.get('rate_covenant', Decimal('1.25')) # 1.25x coverage requirement++ # Calculate coverage ratios+ net_revenues = gross_revenues - operating_expenses+ debt_service_coverage = net_revenues / debt_service if debt_service > 0 else Decimal('999')++ # Additional coverage tests+ additional_bonds_test = debt_service_coverage >= rate_covenant++ # Cash flow analysis+ free_cash_flow = net_revenues - debt_service+ cash_flow_margin = free_cash_flow / gross_revenues if gross_revenues > 0 else Decimal('0')++ # Project viability metrics+ utilization_rate = project_data.get('utilization_rate', Decimal('0.8'))+ capacity_factor = project_data.get('capacity_factor', Decimal('0.9'))++ return {+ 'gross_revenues': gross_revenues,+ 'net_revenues': net_revenues,+ 'debt_service_coverage': debt_service_coverage,+ 'rate_covenant': rate_covenant,+ 'covenant_compliance': additional_bonds_test,+ 'coverage_cushion': debt_service_coverage - rate_covenant,+ 'free_cash_flow': free_cash_flow,+ 'cash_flow_margin_pct': cash_flow_margin * Decimal('100'),+ 'utilization_rate_pct': utilization_rate * Decimal('100'),+ 'capacity_factor_pct': capacity_factor * Decimal('100'),+ 'project_viability': MunicipalBondAnalysis._assess_project_viability(+ debt_service_coverage, utilization_rate, capacity_factor+ )+ }++ @staticmethod+ def _score_debt_burden(debt_per_capita: Decimal, debt_to_av: Decimal) -> Decimal:+ """Score debt burden (0-1 scale)"""+ # Lower debt burden = higher score+ per_capita_score = max(Decimal('0'), Decimal('1') - debt_per_capita / Decimal('5000')) # $5k benchmark+ av_score = max(Decimal('0'), Decimal('1') - debt_to_av / Decimal('0.1')) # 10% benchmark++ return (per_capita_score + av_score) / Decimal('2')++ @staticmethod+ def _score_coverage(coverage_ratio: Decimal) -> Decimal:+ """Score debt service coverage"""+ if coverage_ratio >= Decimal('3'):+ return Decimal('1')+ elif coverage_ratio >= Decimal('2'):+ return Decimal('0.8')+ elif coverage_ratio >= Decimal('1.5'):+ return Decimal('0.6')+ elif coverage_ratio >= Decimal('1.2'):+ return Decimal('0.4')+ else:+ return Decimal('0.2')++ @staticmethod+ def _score_liquidity(fund_balance_ratio: Decimal) -> Decimal:+ """Score liquidity position"""+ if fund_balance_ratio >= Decimal('0.25'): # 25%++ return Decimal('1')+ elif fund_balance_ratio >= Decimal('0.15'): # 15-25%+ return Decimal('0.8')+ elif fund_balance_ratio >= Decimal('0.10'): # 10-15%+ return Decimal('0.6')+ elif fund_balance_ratio >= Decimal('0.05'): # 5-10%+ return Decimal('0.4')+ else:+ return Decimal('0.2')++ @staticmethod+ def _interpret_score(score: Decimal) -> str:+ """Interpret overall credit score"""+ if score >= Decimal('0.8'):+ return 'Strong'+ elif score >= Decimal('0.6'):+ return 'Good'+ elif score >= Decimal('0.4'):+ return 'Satisfactory'+ elif score >= Decimal('0.2'):+ return 'Weak'+ else:+ return 'Distressed'++ @staticmethod+ def _assess_project_viability(coverage: Decimal, utilization: Decimal, capacity: Decimal) -> str:+ """Assess revenue bond project viability"""+ score = (coverage / Decimal('2') + utilization + capacity) / Decimal('3') # Normalize coverage++ if score >= Decimal('0.8'):+ return 'Highly Viable'+ elif score >= Decimal('0.6'):+ return 'Viable'+ elif score >= Decimal('0.4'):+ return 'Marginal'+ else:+ return 'Distressed'+++class AgencyDebtAnalysis:+ """Government agency and GSE debt analysis"""++ @staticmethod+ def agency_types() -> Dict[str, Dict[str, str]]:+ """Classification of government agencies and GSEs"""+ return {+ 'federal_agencies': {+ 'description': 'Direct obligations of US government agencies',+ 'credit_support': 'Full faith and credit backing',+ 'examples': 'GNMA, SBA, Tennessee Valley Authority'+ },+ 'government_sponsored_enterprises': {+ 'description': 'Privately-owned, government-chartered entities',+ 'credit_support': 'Implied government support (historically)',+ 'examples': 'Fannie Mae, Freddie Mac, Federal Home Loan Banks'+ },+ 'supranational_agencies': {+ 'description': 'International organizations',+ 'credit_support': 'Member country support',+ 'examples': 'World Bank, Asian Development Bank, European Investment Bank'+ }+ }++ @staticmethod+ def gse_credit_analysis(gse_data: Dict[str, Decimal]) -> Dict[str, Decimal]:+ """Analyze Government Sponsored Enterprise credit quality"""++ # Capital adequacy+ tier1_capital = gse_data.get('tier1_capital', Decimal('50000000000'))+ risk_weighted_assets = gse_data.get('risk_weighted_assets', Decimal('500000000000'))+ tier1_ratio = tier1_capital / risk_weighted_assets++ # Asset quality+ total_assets = gse_data.get('total_assets', Decimal('1000000000000'))+ non_performing_assets = gse_data.get('non_performing_assets', Decimal('5000000000'))+ npa_ratio = non_performing_assets / total_assets++ # Profitability+ net_income = gse_data.get('net_income', Decimal('10000000000'))+ average_assets = gse_data.get('average_assets', total_assets)+ roa = net_income / average_assets++ # Liquidity+ liquid_assets = gse_data.get('liquid_assets', Decimal('100000000000'))+ short_term_debt = gse_data.get('short_term_debt', Decimal('200000000000'))+ liquidity_ratio = liquid_assets / short_term_debt++ # Government support assessment+ systemic_importance = gse_data.get('market_share', Decimal('0.3')) # 30% market share+ government_ties = gse_data.get('government_charter_score', Decimal('0.8')) # 0-1 scale++ # Overall assessment+ financial_strength = AgencyDebtAnalysis._assess_financial_strength(+ tier1_ratio, npa_ratio, roa, liquidity_ratio+ )++ government_support_score = (systemic_importance + government_ties) / Decimal('2')++ return {+ 'capital_adequacy': {+ 'tier1_ratio_pct': tier1_ratio * Decimal('100'),+ 'regulatory_minimum': Decimal('4'), # 4% minimum+ 'well_capitalized': tier1_ratio >= Decimal('0.06') # 6% well-capitalized+ },+ 'asset_quality': {+ 'npa_ratio_pct': npa_ratio * Decimal('100'),+ 'asset_quality_score': max(Decimal('0'), Decimal('1') - npa_ratio * Decimal('20'))+ },+ 'profitability': {+ 'roa_pct': roa * Decimal('100'),+ 'profitability_score': min(Decimal('1'), max(Decimal('0'), roa * Decimal('100')))+ },+ 'liquidity': {+ 'liquidity_ratio': liquidity_ratio,+ 'liquidity_adequate': liquidity_ratio >= Decimal('0.5')+ },+ 'government_support': {+ 'support_score': government_support_score,+ 'systemic_importance': systemic_importance,+ 'government_ties': government_ties+ },+ 'overall_assessment': {+ 'financial_strength': financial_strength,+ 'government_support': government_support_score,+ 'combined_rating': AgencyDebtAnalysis._derive_rating(financial_strength, government_support_score)+ }+ }++ @staticmethod+ def _assess_financial_strength(tier1_ratio: Decimal, npa_ratio: Decimal,+ roa: Decimal, liquidity_ratio: Decimal) -> Decimal:+ """Assess standalone financial strength (0-1 scale)"""++ # Capital score+ capital_score = min(Decimal('1'), tier1_ratio / Decimal('0.08')) # 8% = perfect++ # Asset quality score+ asset_score = max(Decimal('0'), Decimal('1') - npa_ratio * Decimal('50')) # 2% NPA = 0 score++ # Profitability score+ profit_score = min(Decimal('1'), max(Decimal('0'), roa * Decimal('100'))) # 1% ROA = perfect++ # Liquidity score+ liquidity_score = min(Decimal('1'), liquidity_ratio / Decimal('1')) # 100% = perfect++ # Weighted average+ weights = [Decimal('0.3'), Decimal('0.3'), Decimal('0.2'), Decimal('0.2')]+ scores = [capital_score, asset_score, profit_score, liquidity_score]++ return sum(w * s for w, s in zip(weights, scores))++ @staticmethod+ def _derive_rating(financial_strength: Decimal, government_support: Decimal) -> str:+ """Derive credit rating from financial strength and government support"""++ # Combined score with higher weight on government support for GSEs+ combined_score = financial_strength * Decimal('0.4') + government_support * Decimal('0.6')++ if combined_score >= Decimal('0.9'):+ return 'AAA'+ elif combined_score >= Decimal('0.8'):+ return 'AA'+ elif combined_score >= Decimal('0.7'):+ return 'A'+ elif combined_score >= Decimal('0.6'):+ return 'BBB'+ elif combined_score >= Decimal('0.5'):+ return 'BB'+ else:+ return 'B'+++class InflationLinkedBonds:+ """Inflation-linked government bond analysis"""++ @staticmethod+ def tips_analysis(principal: Decimal, coupon_rate: Decimal,+ inflation_rate: Decimal, years_remaining: Decimal) -> Dict[str, Decimal]:+ """Analyze Treasury Inflation-Protected Securities (TIPS)"""+ ValidationUtils.validate_positive(principal, "Principal")+ ValidationUtils.validate_positive(coupon_rate, "Coupon rate")+ ValidationUtils.validate_percentage(inflation_rate, "Inflation rate", allow_negative=True)+ ValidationUtils.validate_positive(years_remaining, "Years remaining")++ # Inflation-adjusted principal+ inflation_factor = (Decimal('1') + inflation_rate) ** years_remaining+ adjusted_principal = principal * inflation_factor++ # Annual coupon payment (based on adjusted principal)+ annual_coupon = adjusted_principal * coupon_rate++ # Real yield calculation (simplified)+ nominal_yield = coupon_rate + inflation_rate # Approximation+ real_yield = coupon_rate # TIPS coupon rate is the real yield++ # Breakeven inflation rate (what inflation needs to be for TIPS to outperform nominals)+ nominal_bond_yield = Decimal('0.05') # Assume 5% nominal Treasury yield+ breakeven_inflation = nominal_bond_yield - real_yield++ return {+ 'original_principal': principal,+ 'inflation_adjusted_principal': adjusted_principal,+ 'inflation_adjustment_factor': inflation_factor,+ 'annual_coupon_payment': annual_coupon,+ 'real_yield': real_yield,+ 'nominal_yield_equivalent': nominal_yield,+ 'breakeven_inflation_rate': breakeven_inflation,+ 'inflation_protection': inflation_rate - breakeven_inflation,+ 'attractive_vs_nominal': inflation_rate > breakeven_inflation+ }++ @staticmethod+ def inflation_swap_analysis(notional: Decimal, fixed_rate: Decimal,+ expected_inflation: Decimal, tenor: Decimal) -> Dict[str, Decimal]:+ """Analyze inflation swap for hedging purposes"""+ ValidationUtils.validate_positive(notional, "Notional")+ ValidationUtils.validate_yield(fixed_rate, "Fixed rate")+ ValidationUtils.validate_percentage(expected_inflation, "Expected inflation", allow_negative=True)+ ValidationUtils.validate_positive(tenor, "Tenor")++ # Inflation swap PV calculation (simplified)+ fixed_leg_pv = notional * fixed_rate * tenor # Simplified fixed leg++ # Floating leg expected value+ floating_leg_pv = notional * expected_inflation * tenor++ # Swap value to fixed rate payer+ swap_value = floating_leg_pv - fixed_leg_pv++ # Breakeven inflation+ breakeven = fixed_rate++ return {+ 'notional_amount': notional,+ 'fixed_rate': fixed_rate,+ 'expected_inflation': expected_inflation,+ 'fixed_leg_pv': fixed_leg_pv,+ 'floating_leg_pv': floating_leg_pv,+ 'swap_value_to_payer': swap_value,+ 'breakeven_inflation': breakeven,+ 'inflation_expectation_vs_breakeven': expected_inflation - breakeven+ }+++# Utility functions for government debt analysis+def sovereign_debt_comparison(countries: Dict[str, Dict[str, Decimal]]) -> Dict[str, Dict]:+ """Compare sovereign debt metrics across countries"""++ comparison = {}++ for country, data in countries.items():+ sustainability = SovereignCreditAnalysis.debt_sustainability_analysis(data)++ comparison[country] = {+ 'debt_gdp_ratio': data.get('debt_to_gdp', Decimal('0')),+ 'sustainability_score': sustainability['sustainability_score'],+ 'fiscal_space': sustainability['fiscal_space'],+ 'sustainable': sustainability['sustainable'],+ 'projected_debt_5y': sustainability['projected_debt_gdp_5y']+ }++ # Rank countries by sustainability+ ranked = sorted(comparison.items(),+ key=lambda x: x[1]['sustainability_score'],+ reverse=True)++ return {+ 'country_analysis': comparison,+ 'ranking_by_sustainability': [country for country, _ in ranked],+ 'summary_statistics': {+ 'average_debt_gdp': sum(data['debt_gdp_ratio'] for data in comparison.values()) / len(comparison),+ 'countries_sustainable': sum(1 for data in comparison.values() if data['sustainable']),+ 'total_countries': len(comparison)+ }+ }+++def municipal_portfolio_analysis(portfolio: Portfolio,+ muni_data: Dict[str, Dict[str, Decimal]]) -> Dict[str, any]:+ """Analyze municipal bond portfolio"""++ total_exposure = Decimal('0')+ go_exposure = Decimal('0')+ revenue_exposure = Decimal('0')++ issuer_analysis = {}++ for bond, quantity in portfolio.holdings:+ if bond.sector == 'Municipal':+ exposure = bond.face_value * quantity+ total_exposure += exposure++ issuer = bond.issuer_name+ if issuer in muni_data:+ issuer_data = muni_data[issuer]++ # Determine bond type and analyze+ if issuer_data.get('bond_type') == 'GO':+ go_exposure += exposure+ analysis = MunicipalBondAnalysis.go_bond_analysis(issuer_data)+ else:+ revenue_exposure += exposure+ analysis = MunicipalBondAnalysis.revenue_bond_analysis(issuer_data)++ issuer_analysis[issuer] = {+ 'exposure': exposure,+ 'analysis': analysis,+ 'weight': exposure / total_exposure if total_exposure > 0 else Decimal('0')+ }++ return {+ 'portfolio_composition': {+ 'total_municipal_exposure': total_exposure,+ 'go_bond_exposure': go_exposure,+ 'revenue_bond_exposure': revenue_exposure,+ 'go_percentage': go_exposure / total_exposure if total_exposure > 0 else Decimal('0'),+ 'revenue_percentage': revenue_exposure / total_exposure if total_exposure > 0 else Decimal('0')+ },+ 'issuer_analysis': issuer_analysis,+ 'portfolio_quality_metrics': {+ 'weighted_avg_coverage': sum(+ data['analysis'].get('debt_service_coverage', Decimal('1')) * data['weight']+ for data in issuer_analysis.values()+ ),+ 'number_of_issuers': len(issuer_analysis),+ 'concentration_risk': max(+ data['weight'] for data in issuer_analysis.values()) if issuer_analysis else Decimal('0')+ }+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/instruments.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/instruments.pynew file mode 100644index 000000000..5784143bf--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/instruments.py@@ -0,0 +1,471 @@++Fixed Income Instruments Module+=================================++Fixed income instrument definitions++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Optional, Dict, Tuple+from decimal import Decimal+from datetime import date, timedelta+from models import (+ Bond, CallableBond, PutableBond, FloatingRateNote, ConvertibleBond,+ CashFlow, CallableFeature, PutableFeature, ValidationError+)+from config import (+ DayCountConvention, CompoundingFrequency, BusinessDayConvention,+ Currency, BondType, get_market_convention+)+++class BondInstrument:+ """Base bond instrument class with core functionality"""++ def __init__(self, bond: Bond):+ self.bond = bond+ self._cash_flows = None++ def generate_cash_flows(self, settlement_date: Optional[date] = None) -> List[CashFlow]:+ """Generate bond cash flows from settlement date to maturity"""+ if settlement_date is None:+ settlement_date = date.today()++ cash_flows = []++ # For zero coupon bonds, only final payment+ if self.bond.is_zero_coupon:+ cash_flows.append(CashFlow(+ date=self.bond.maturity_date,+ amount=self.bond.face_value,+ type="principal"+ ))+ return cash_flows++ # Generate coupon payment dates+ coupon_dates = self._generate_coupon_dates(settlement_date)++ # Generate coupon payments+ coupon_amount = self._calculate_coupon_amount()++ for coupon_date in coupon_dates:+ if coupon_date > settlement_date:+ cash_flows.append(CashFlow(+ date=coupon_date,+ amount=coupon_amount,+ type="coupon"+ ))++ # Add principal repayment at maturity+ if cash_flows: # If there are coupon payments+ cash_flows[-1].amount += self.bond.face_value+ cash_flows[-1].type = "coupon_and_principal"+ else: # If no future coupons, just principal+ cash_flows.append(CashFlow(+ date=self.bond.maturity_date,+ amount=self.bond.face_value,+ type="principal"+ ))++ self._cash_flows = cash_flows+ return cash_flows++ def _generate_coupon_dates(self, start_date: date) -> List[date]:+ """Generate coupon payment dates"""+ dates = []+ frequency = self.bond.coupon_frequency.value++ if frequency == 0: # Continuous compounding - treat as annual+ frequency = 1++ # Calculate months between payments+ months_between = 12 // frequency++ # Start from maturity and work backwards+ current_date = self.bond.maturity_date++ while current_date > self.bond.issue_date:+ dates.append(current_date)+ # Subtract months+ if current_date.month <= months_between:+ new_month = 12 + current_date.month - months_between+ new_year = current_date.year - 1+ else:+ new_month = current_date.month - months_between+ new_year = current_date.year++ try:+ current_date = current_date.replace(year=new_year, month=new_month)+ except ValueError:+ # Handle end-of-month dates+ if new_month == 2 and current_date.day > 28:+ current_date = current_date.replace(year=new_year, month=new_month, day=28)+ else:+ current_date = current_date.replace(year=new_year, month=new_month, day=1)+ current_date = current_date.replace(day=min(current_date.day,+ self._days_in_month(new_year, new_month)))++ # Reverse to get chronological order+ dates.reverse()+ return dates++ def _days_in_month(self, year: int, month: int) -> int:+ """Get number of days in a month"""+ if month == 12:+ next_month = date(year + 1, 1, 1)+ else:+ next_month = date(year, month + 1, 1)+ this_month = date(year, month, 1)+ return (next_month - this_month).days++ def _calculate_coupon_amount(self) -> Decimal:+ """Calculate coupon payment amount"""+ annual_coupon = self.bond.face_value * self.bond.coupon_rate+ frequency = self.bond.coupon_frequency.value++ if frequency == 0: # Continuous compounding+ return annual_coupon++ return annual_coupon / Decimal(frequency)++ def accrued_interest(self, settlement_date: date) -> Decimal:+ """Calculate accrued interest from last coupon date"""+ if self.bond.is_zero_coupon:+ return Decimal('0')++ coupon_dates = self._generate_coupon_dates(self.bond.issue_date)++ # Find last coupon date before settlement+ last_coupon_date = self.bond.issue_date+ for coupon_date in coupon_dates:+ if coupon_date <= settlement_date:+ last_coupon_date = coupon_date+ else:+ break++ # Calculate accrual period+ days_accrued = self._calculate_days(last_coupon_date, settlement_date)+ days_in_period = self._calculate_days_in_coupon_period(last_coupon_date)++ coupon_amount = self._calculate_coupon_amount()++ return coupon_amount * (Decimal(days_accrued) / Decimal(days_in_period))++ def _calculate_days(self, start_date: date, end_date: date) -> int:+ """Calculate days between dates based on day count convention"""+ if self.bond.day_count_convention == DayCountConvention.ACTUAL_360:+ return (end_date - start_date).days+ elif self.bond.day_count_convention == DayCountConvention.ACTUAL_365:+ return (end_date - start_date).days+ elif self.bond.day_count_convention == DayCountConvention.ACTUAL_ACTUAL:+ return (end_date - start_date).days+ elif self.bond.day_count_convention == DayCountConvention.THIRTY_360:+ return self._thirty_360_days(start_date, end_date)+ else:+ return (end_date - start_date).days++ def _thirty_360_days(self, start_date: date, end_date: date) -> int:+ """Calculate days using 30/360 convention"""+ d1 = min(start_date.day, 30)+ d2 = min(end_date.day, 30) if d1 == 30 else end_date.day++ return (360 * (end_date.year - start_date.year) ++ 30 * (end_date.month - start_date.month) ++ (d2 - d1))++ def _calculate_days_in_coupon_period(self, coupon_date: date) -> int:+ """Calculate days in coupon period"""+ frequency = self.bond.coupon_frequency.value+ if frequency == 0:+ frequency = 1++ if self.bond.day_count_convention == DayCountConvention.THIRTY_360:+ return 360 // frequency+ else:+ return 365 // frequency # Approximation++ def time_to_maturity(self, settlement_date: Optional[date] = None) -> Decimal:+ """Calculate time to maturity in years"""+ if settlement_date is None:+ settlement_date = date.today()++ days = (self.bond.maturity_date - settlement_date).days++ if self.bond.day_count_convention == DayCountConvention.ACTUAL_365:+ return Decimal(days) / Decimal('365')+ elif self.bond.day_count_convention == DayCountConvention.ACTUAL_360:+ return Decimal(days) / Decimal('360')+ else:+ return Decimal(days) / Decimal('365.25') # Default+++class CallableBondInstrument(BondInstrument):+ """Callable bond instrument with embedded call option"""++ def __init__(self, callable_bond: CallableBond):+ super().__init__(callable_bond)+ self.callable_bond = callable_bond++ def is_callable_on_date(self, check_date: date) -> bool:+ """Check if bond is callable on a specific date"""+ for call_feature in self.callable_bond.call_schedule:+ if call_feature.call_date == check_date:+ return True+ return False++ def get_call_price(self, call_date: date) -> Optional[Decimal]:+ """Get call price for a specific date"""+ for call_feature in self.callable_bond.call_schedule:+ if call_feature.call_date == call_date:+ return call_feature.call_price+ return None++ def next_call_date(self, from_date: Optional[date] = None) -> Optional[date]:+ """Get next call date after specified date"""+ if from_date is None:+ from_date = date.today()++ next_call = None+ for call_feature in self.callable_bond.call_schedule:+ if call_feature.call_date > from_date:+ if next_call is None or call_feature.call_date < next_call:+ next_call = call_feature.call_date++ return next_call++ def effective_maturity(self, yield_to_call: Decimal, yield_to_maturity: Decimal) -> date:+ """Determine effective maturity based on yield comparison"""+ next_call = self.next_call_date()++ if next_call and yield_to_call < yield_to_maturity:+ return next_call+ else:+ return self.bond.maturity_date+++class PutableBondInstrument(BondInstrument):+ """Putable bond instrument with embedded put option"""++ def __init__(self, putable_bond: PutableBond):+ super().__init__(putable_bond)+ self.putable_bond = putable_bond++ def is_putable_on_date(self, check_date: date) -> bool:+ """Check if bond is putable on a specific date"""+ for put_feature in self.putable_bond.put_schedule:+ if put_feature.put_date == check_date:+ return True+ return False++ def get_put_price(self, put_date: date) -> Optional[Decimal]:+ """Get put price for a specific date"""+ for put_feature in self.putable_bond.put_schedule:+ if put_feature.put_date == put_date:+ return put_feature.put_price+ return None++ def next_put_date(self, from_date: Optional[date] = None) -> Optional[date]:+ """Get next put date after specified date"""+ if from_date is None:+ from_date = date.today()++ next_put = None+ for put_feature in self.putable_bond.put_schedule:+ if put_feature.put_date > from_date:+ if next_put is None or put_feature.put_date < next_put:+ next_put = put_feature.put_date++ return next_put+++class FloatingRateNoteInstrument(BondInstrument):+ """Floating rate note instrument"""++ def __init__(self, frn: FloatingRateNote):+ super().__init__(frn)+ self.frn = frn+ self._current_reference_rate = Decimal('0')++ def set_reference_rate(self, rate: Decimal):+ """Set current reference rate"""+ self._current_reference_rate = rate++ def current_coupon_rate(self) -> Decimal:+ """Calculate current coupon rate"""+ base_rate = self._current_reference_rate + self.frn.spread++ # Apply cap and floor if specified+ if self.frn.rate_cap and base_rate > self.frn.rate_cap:+ return self.frn.rate_cap++ if self.frn.rate_floor and base_rate < self.frn.rate_floor:+ return self.frn.rate_floor++ return base_rate++ def generate_cash_flows_with_rate_path(self, rate_path: List[Tuple[date, Decimal]]) -> List[CashFlow]:+ """Generate cash flows given a path of reference rates"""+ cash_flows = []+ coupon_dates = self._generate_coupon_dates(date.today())++ for i, coupon_date in enumerate(coupon_dates):+ if coupon_date > date.today():+ # Find applicable rate for this period+ applicable_rate = self._find_rate_for_period(rate_path, coupon_date)++ # Calculate coupon amount+ coupon_rate = applicable_rate + self.frn.spread++ # Apply caps and floors+ if self.frn.rate_cap:+ coupon_rate = min(coupon_rate, self.frn.rate_cap)+ if self.frn.rate_floor:+ coupon_rate = max(coupon_rate, self.frn.rate_floor)++ # Calculate payment amount+ coupon_amount = self.frn.face_value * coupon_rate / Decimal(self.frn.coupon_frequency.value)++ cash_flows.append(CashFlow(+ date=coupon_date,+ amount=coupon_amount,+ type="coupon"+ ))++ # Add principal at maturity+ if cash_flows:+ cash_flows[-1].amount += self.frn.face_value+ cash_flows[-1].type = "coupon_and_principal"++ return cash_flows++ def _find_rate_for_period(self, rate_path: List[Tuple[date, Decimal]], period_end: date) -> Decimal:+ """Find the reference rate applicable for a coupon period"""+ applicable_rate = Decimal('0')++ for rate_date, rate in rate_path:+ if rate_date <= period_end:+ applicable_rate = rate+ else:+ break++ return applicable_rate+++class ConvertibleBondInstrument(BondInstrument):+ """Convertible bond instrument"""++ def __init__(self, convertible: ConvertibleBond):+ super().__init__(convertible)+ self.convertible = convertible++ def conversion_value(self, stock_price: Optional[Decimal] = None) -> Decimal:+ """Calculate conversion value"""+ if stock_price is None:+ stock_price = self.convertible.underlying_stock_price++ if stock_price is None:+ raise ValidationError("Stock price required for conversion value calculation")++ return self.convertible.conversion_ratio * stock_price++ def conversion_premium(self, bond_price: Decimal, stock_price: Optional[Decimal] = None) -> Decimal:+ """Calculate conversion premium"""+ conv_value = self.conversion_value(stock_price)+ return bond_price - conv_value++ def conversion_premium_percentage(self, bond_price: Decimal, stock_price: Optional[Decimal] = None) -> Decimal:+ """Calculate conversion premium as percentage"""+ conv_value = self.conversion_value(stock_price)+ if conv_value == 0:+ return Decimal('0')++ premium = self.conversion_premium(bond_price, stock_price)+ return premium / conv_value * Decimal('100')++ def payback_period(self, bond_price: Decimal, dividend_yield: Optional[Decimal] = None) -> Optional[Decimal]:+ """Calculate payback period in years"""+ if dividend_yield is None:+ dividend_yield = self.convertible.dividend_yield++ if dividend_yield is None or dividend_yield == 0:+ return None++ coupon_yield = (self.convertible.coupon_rate * self.convertible.face_value) / bond_price+ yield_advantage = coupon_yield - dividend_yield++ if yield_advantage <= 0:+ return None++ premium_pct = self.conversion_premium_percentage(bond_price) / Decimal('100')+ return premium_pct / yield_advantage++ def delta(self, bond_price: Decimal, stock_price: Decimal) -> Decimal:+ """Calculate convertible bond delta (sensitivity to stock price)"""+ # Simplified delta calculation+ conv_value = self.conversion_value(stock_price)++ if bond_price <= conv_value:+ return self.convertible.conversion_ratio+ else:+ # Approximate delta for out-of-the-money convertible+ return self.convertible.conversion_ratio * (conv_value / bond_price)+++# Factory functions for instrument creation+def create_bond_instrument(bond: Bond) -> BondInstrument:+ """Factory function to create appropriate instrument type"""+ if isinstance(bond, CallableBond):+ return CallableBondInstrument(bond)+ elif isinstance(bond, PutableBond):+ return PutableBondInstrument(bond)+ elif isinstance(bond, FloatingRateNote):+ return FloatingRateNoteInstrument(bond)+ elif isinstance(bond, ConvertibleBond):+ return ConvertibleBondInstrument(bond)+ else:+ return BondInstrument(bond)+++def create_callable_bond_with_schedule(base_bond: Bond,+ call_schedule: List[Tuple[date, Decimal]]) -> CallableBondInstrument:+ """Create callable bond with call schedule"""+ call_features = [CallableFeature(call_date=date, call_price=price) for date, price in call_schedule]++ callable_bond = CallableBond(+ isin=base_bond.isin,+ cusip=base_bond.cusip,+ ticker=base_bond.ticker,+ issue_date=base_bond.issue_date,+ maturity_date=base_bond.maturity_date,+ face_value=base_bond.face_value,+ currency=base_bond.currency,+ coupon_rate=base_bond.coupon_rate,+ coupon_frequency=base_bond.coupon_frequency,+ day_count_convention=base_bond.day_count_convention,+ issuer_name=base_bond.issuer_name,+ issuer_rating=base_bond.issuer_rating,+ call_schedule=call_features+ )++ return CallableBondInstrument(callable_bond)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/models.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/models.pynew file mode 100644index 000000000..793a93f5a--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/models.py@@ -0,0 +1,429 @@++Fixed Income Models Module+=================================++Fixed income modeling and valuation++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from dataclasses import dataclass, field+from typing import List, Dict, Optional, Union, Tuple+from decimal import Decimal+from datetime import datetime, date+from config import (+ DayCountConvention, CompoundingFrequency, BusinessDayConvention,+ Currency, CreditRating, BondType, SecuritizationType,+ VALIDATION_RULES, ValidationError+)+++@dataclass+class CashFlow:+ """Represents a single cash flow"""+ date: date+ amount: Decimal+ type: str = "coupon" # coupon, principal, fee++ def __post_init__(self):+ if self.amount < 0:+ raise ValidationError("Cash flow amount cannot be negative")+++@dataclass+class YieldCurve:+ """Yield curve data structure"""+ curve_date: date+ maturities: List[Decimal] # Years to maturity+ rates: List[Decimal] # Zero-coupon rates+ currency: Currency = Currency.USD+ curve_type: str = "spot" # spot, forward, par, swap++ def __post_init__(self):+ if len(self.maturities) != len(self.rates):+ raise ValidationError("Maturities and rates must have same length")++ if any(rate < VALIDATION_RULES['min_yield'] for rate in self.rates):+ raise ValidationError("Yield below minimum threshold")++ if any(rate > VALIDATION_RULES['max_yield'] for rate in self.rates):+ raise ValidationError("Yield above maximum threshold")+++@dataclass+class CreditSpread:+ """Credit spread data structure"""+ rating: CreditRating+ maturity: Decimal+ spread: Decimal # Basis points over benchmark+ sector: Optional[str] = None++ def __post_init__(self):+ if self.spread < 0:+ raise ValidationError("Credit spread cannot be negative")+++@dataclass+class Bond:+ """Base bond data model"""+ # Identification+ isin: str+ cusip: Optional[str] = None+ ticker: Optional[str] = None++ # Basic characteristics+ issue_date: date+ maturity_date: date+ face_value: Decimal = Decimal('100')+ currency: Currency = Currency.USD++ # Coupon details+ coupon_rate: Decimal = Decimal('0')+ coupon_frequency: CompoundingFrequency = CompoundingFrequency.SEMI_ANNUAL+ day_count_convention: DayCountConvention = DayCountConvention.THIRTY_360++ # Issuer information+ issuer_name: str = ""+ issuer_rating: Optional[CreditRating] = None+ sector: Optional[str] = None+ country: Optional[str] = None++ # Market data+ current_price: Optional[Decimal] = None+ current_yield: Optional[Decimal] = None++ # Bond type and features+ bond_type: BondType = BondType.FIXED_RATE+ callable: bool = False+ putable: bool = False++ # Settlement+ settlement_days: int = 3+ business_day_convention: BusinessDayConvention = BusinessDayConvention.MODIFIED_FOLLOWING++ def __post_init__(self):+ self._validate()++ def _validate(self):+ """Validate bond parameters"""+ if self.maturity_date <= self.issue_date:+ raise ValidationError("Maturity date must be after issue date")++ if self.coupon_rate < VALIDATION_RULES['min_coupon_rate']:+ raise ValidationError("Coupon rate below minimum")++ if self.coupon_rate > VALIDATION_RULES['max_coupon_rate']:+ raise ValidationError("Coupon rate above maximum")++ if self.current_price and (+ self.current_price < VALIDATION_RULES['min_price'] or+ self.current_price > VALIDATION_RULES['max_price']+ ):+ raise ValidationError("Bond price outside valid range")++ @property+ def time_to_maturity(self) -> Decimal:+ """Calculate time to maturity in years"""+ today = date.today()+ days_to_maturity = (self.maturity_date - today).days+ return Decimal(days_to_maturity) / Decimal('365.25')++ @property+ def is_zero_coupon(self) -> bool:+ """Check if bond is zero coupon"""+ return self.coupon_rate == 0 or self.bond_type == BondType.ZERO_COUPON+++@dataclass+class CallableFeature:+ """Callable bond feature"""+ call_date: date+ call_price: Decimal+ call_type: str = "american" # american, european, bermudan++ def __post_init__(self):+ if self.call_price <= 0:+ raise ValidationError("Call price must be positive")+++@dataclass+class PutableFeature:+ """Putable bond feature"""+ put_date: date+ put_price: Decimal+ put_type: str = "european"++ def __post_init__(self):+ if self.put_price <= 0:+ raise ValidationError("Put price must be positive")+++@dataclass+class CallableBond(Bond):+ """Callable bond model"""+ call_schedule: List[CallableFeature] = field(default_factory=list)++ def __post_init__(self):+ super().__post_init__()+ self.callable = True+ self.bond_type = BondType.CALLABLE+++@dataclass+class PutableBond(Bond):+ """Putable bond model"""+ put_schedule: List[PutableFeature] = field(default_factory=list)++ def __post_init__(self):+ super().__post_init__()+ self.putable = True+ self.bond_type = BondType.PUTABLE+++@dataclass+class FloatingRateNote(Bond):+ """Floating rate note model"""+ reference_rate: str = "LIBOR" # LIBOR, SOFR, EURIBOR, etc.+ spread: Decimal = Decimal('0') # Spread over reference rate+ reset_frequency: CompoundingFrequency = CompoundingFrequency.QUARTERLY+ rate_cap: Optional[Decimal] = None+ rate_floor: Optional[Decimal] = None++ def __post_init__(self):+ super().__post_init__()+ self.bond_type = BondType.FLOATING_RATE+ self.coupon_rate = Decimal('0') # Will be set by reference rate+++@dataclass+class ConvertibleBond(Bond):+ """Convertible bond model"""+ conversion_ratio: Decimal = Decimal('1')+ conversion_price: Decimal = Decimal('100')+ underlying_stock_price: Optional[Decimal] = None+ stock_volatility: Optional[Decimal] = None+ dividend_yield: Optional[Decimal] = None++ def __post_init__(self):+ super().__post_init__()+ self.bond_type = BondType.CONVERTIBLE++ @property+ def conversion_value(self) -> Optional[Decimal]:+ """Calculate conversion value"""+ if self.underlying_stock_price:+ return self.conversion_ratio * self.underlying_stock_price+ return None+++@dataclass+class SecuritizedBond:+ """Base securitized product model"""+ # Identification+ cusip: str+ pool_number: Optional[str] = None++ # Structure details+ securitization_type: SecuritizationType = SecuritizationType.ABS+ original_balance: Decimal = Decimal('0')+ current_balance: Decimal = Decimal('0')++ # Underlying assets+ collateral_type: str = ""+ weighted_average_maturity: Optional[Decimal] = None+ weighted_average_coupon: Optional[Decimal] = None++ # Credit enhancement+ credit_enhancement_level: Decimal = Decimal('0')+ enhancement_type: str = "" # subordination, overcollateralization, insurance++ # Prepayment+ prepayment_speed: Optional[Decimal] = None # CPR or PSA++ def __post_init__(self):+ if self.current_balance > self.original_balance:+ raise ValidationError("Current balance cannot exceed original balance")+++@dataclass+class MortgagePassThrough(SecuritizedBond):+ """Mortgage pass-through security"""+ agency: str = "" # GNMA, FNMA, FHLMC+ pool_type: str = "" # single-family, multi-family++ def __post_init__(self):+ super().__post_init__()+ self.securitization_type = SecuritizationType.MORTGAGE_PASS_THROUGH+++@dataclass+class AssetBackedSecurity(SecuritizedBond):+ """Asset-backed security"""+ asset_class: str = "" # auto loans, credit cards, student loans+ geographic_concentration: Optional[str] = None++ def __post_init__(self):+ super().__post_init__()+ self.securitization_type = SecuritizationType.ABS+++@dataclass+class CreditDefaultSwap:+ """Credit default swap model"""+ # Contract details+ reference_entity: str+ notional_amount: Decimal+ maturity_date: date++ # Pricing+ spread: Decimal # Basis points per annum+ upfront_payment: Decimal = Decimal('0')+ recovery_rate: Decimal = Decimal('0.40') # 40% default assumption++ # Contract specifications+ settlement_type: str = "physical" # physical, cash+ credit_events: List[str] = field(default_factory=lambda: ["bankruptcy", "failure_to_pay"])++ def __post_init__(self):+ if self.spread < 0:+ raise ValidationError("CDS spread cannot be negative")++ if not (0 <= self.recovery_rate <= 1):+ raise ValidationError("Recovery rate must be between 0 and 1")+++@dataclass+class Portfolio:+ """Fixed income portfolio model"""+ name: str+ holdings: List[Tuple[Union[Bond, SecuritizedBond], Decimal]] = field(default_factory=list) # (instrument, quantity)+ cash_position: Decimal = Decimal('0')+ base_currency: Currency = Currency.USD++ def add_holding(self, instrument: Union[Bond, SecuritizedBond], quantity: Decimal):+ """Add holding to portfolio"""+ if quantity <= 0:+ raise ValidationError("Quantity must be positive")+ self.holdings.append((instrument, quantity))++ def remove_holding(self, instrument: Union[Bond, SecuritizedBond]):+ """Remove holding from portfolio"""+ self.holdings = [(inst, qty) for inst, qty in self.holdings if inst != instrument]++ @property+ def total_positions(self) -> int:+ """Get total number of positions"""+ return len(self.holdings)++ @property+ def total_face_value(self) -> Decimal:+ """Calculate total face value of portfolio"""+ total = Decimal('0')+ for instrument, quantity in self.holdings:+ if hasattr(instrument, 'face_value'):+ total += instrument.face_value * quantity+ elif hasattr(instrument, 'current_balance'):+ total += instrument.current_balance * quantity+ return total+++@dataclass+class MarketData:+ """Market data container"""+ date: date+ yield_curves: Dict[Currency, YieldCurve] = field(default_factory=dict)+ credit_spreads: Dict[str, List[CreditSpread]] = field(default_factory=dict) # sector -> spreads+ exchange_rates: Dict[str, Decimal] = field(default_factory=dict) # currency pair -> rate+ volatilities: Dict[str, Decimal] = field(default_factory=dict) # instrument -> volatility++ def add_yield_curve(self, currency: Currency, curve: YieldCurve):+ """Add yield curve for currency"""+ self.yield_curves[currency] = curve++ def get_yield_curve(self, currency: Currency) -> Optional[YieldCurve]:+ """Get yield curve for currency"""+ return self.yield_curves.get(currency)++ def add_credit_spreads(self, sector: str, spreads: List[CreditSpread]):+ """Add credit spreads for sector"""+ self.credit_spreads[sector] = spreads++ def get_credit_spreads(self, sector: str) -> List[CreditSpread]:+ """Get credit spreads for sector"""+ return self.credit_spreads.get(sector, [])+++# Factory functions for creating common instruments+def create_treasury_bond(maturity_years: Decimal, coupon_rate: Decimal,+ currency: Currency = Currency.USD) -> Bond:+ """Create a treasury bond"""+ today = date.today()+ maturity_date = date(today.year + int(maturity_years), today.month, today.day)++ return Bond(+ isin=f"US{today.strftime('%Y%m%d')}{maturity_years}",+ issue_date=today,+ maturity_date=maturity_date,+ coupon_rate=coupon_rate,+ currency=currency,+ issuer_name="U.S. Treasury",+ issuer_rating=CreditRating.AAA,+ sector="Government"+ )+++def create_corporate_bond(issuer: str, maturity_years: Decimal,+ coupon_rate: Decimal, rating: CreditRating) -> Bond:+ """Create a corporate bond"""+ today = date.today()+ maturity_date = date(today.year + int(maturity_years), today.month, today.day)++ return Bond(+ isin=f"CORP{today.strftime('%Y%m%d')}{maturity_years}",+ issue_date=today,+ maturity_date=maturity_date,+ coupon_rate=coupon_rate,+ issuer_name=issuer,+ issuer_rating=rating,+ sector="Corporate"+ )+++def create_zero_coupon_bond(maturity_years: Decimal, currency: Currency = Currency.USD) -> Bond:+ """Create a zero coupon bond"""+ today = date.today()+ maturity_date = date(today.year + int(maturity_years), today.month, today.day)++ return Bond(+ isin=f"ZERO{today.strftime('%Y%m%d')}{maturity_years}",+ issue_date=today,+ maturity_date=maturity_date,+ coupon_rate=Decimal('0'),+ currency=currency,+ bond_type=BondType.ZERO_COUPON+ )+++class ValidationError(Exception):+ """Custom validation error"""+ pass\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/risk_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/risk_analytics.pynew file mode 100644index 000000000..361314985--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/risk_analytics.py@@ -0,0 +1,573 @@++Fixed Income Risk Analytics Module+=================================++Fixed income risk analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Dict, Optional, Tuple+from decimal import Decimal+from datetime import date+import math+from models import Bond, Portfolio, CashFlow+from instruments import create_bond_instrument+from yield_curves import SpotCurve+from valuation import BondValuation, ArbitrageFreeValuation+from utils import MathUtils, DateUtils, ValidationUtils, cache_calculation+from config import CompoundingFrequency, ERROR_TOLERANCE+++class DurationMeasures:+ """Duration calculations for fixed income securities"""++ @staticmethod+ @cache_calculation+ def macaulay_duration(bond: Bond, yield_rate: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate Macaulay duration"""+ ValidationUtils.validate_yield(yield_rate, "Yield rate")++ if settlement_date is None:+ settlement_date = date.today()++ bond_instrument = create_bond_instrument(bond)+ cash_flows = bond_instrument.generate_cash_flows(settlement_date)++ if not cash_flows:+ return Decimal('0')++ # Calculate weighted average time to maturity+ total_pv = Decimal('0')+ weighted_time = Decimal('0')++ for cf in cash_flows:+ time_to_payment = DateUtils.calculate_day_count_fraction(+ settlement_date, cf.date, bond.day_count_convention+ )++ pv = MathUtils.present_value(cf.amount, yield_rate, time_to_payment)+ total_pv += pv+ weighted_time += time_to_payment * pv++ if total_pv == 0:+ return Decimal('0')++ return weighted_time / total_pv++ @staticmethod+ def modified_duration(bond: Bond, yield_rate: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate Modified duration"""+ mac_duration = DurationMeasures.macaulay_duration(bond, yield_rate, settlement_date)++ # Get compounding frequency+ frequency = bond.coupon_frequency.value+ if frequency == 0: # Continuous compounding+ return mac_duration++ return mac_duration / (Decimal('1') + yield_rate / Decimal(str(frequency)))++ @staticmethod+ def effective_duration(bond: Bond, base_curve: SpotCurve,+ yield_shift: Decimal = Decimal('0.0001')) -> Decimal:+ """Calculate Effective duration using curve shifts"""+ ValidationUtils.validate_positive(yield_shift, "Yield shift")++ # Calculate prices with up and down shifts+ up_curve = base_curve.shift_curve(yield_shift, "parallel")+ down_curve = base_curve.shift_curve(-yield_shift, "parallel")++ base_price = BondValuation.present_value_with_curve(bond, base_curve)+ up_price = BondValuation.present_value_with_curve(bond, up_curve)+ down_price = BondValuation.present_value_with_curve(bond, down_curve)++ # Effective duration = -(P- - P+) / (2 * P0 * Δy)+ if base_price == 0:+ return Decimal('0')++ return -(down_price - up_price) / (Decimal('2') * base_price * yield_shift)++ @staticmethod+ def money_duration(bond: Bond, yield_rate: Decimal, price: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate Money duration (Modified duration × Price)"""+ mod_duration = DurationMeasures.modified_duration(bond, yield_rate, settlement_date)+ return mod_duration * price++ @staticmethod+ def dollar_duration(bond: Bond, yield_rate: Decimal, price: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate Dollar duration (Money duration × 0.01)"""+ money_dur = DurationMeasures.money_duration(bond, yield_rate, price, settlement_date)+ return money_dur * Decimal('0.01')++ @staticmethod+ def price_value_basis_point(bond: Bond, yield_rate: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate Price Value of a Basis Point (PVBP)"""+ if settlement_date is None:+ settlement_date = date.today()++ # Calculate price at current yield and yield + 1bp+ base_price = BondValuation.present_value(bond, yield_rate, settlement_date)+ shifted_price = BondValuation.present_value(bond, yield_rate + Decimal('0.0001'), settlement_date)++ return base_price - shifted_price+++class ConvexityMeasures:+ """Convexity calculations for fixed income securities"""++ @staticmethod+ @cache_calculation+ def effective_convexity(bond: Bond, base_curve: SpotCurve,+ yield_shift: Decimal = Decimal('0.0001')) -> Decimal:+ """Calculate Effective convexity using curve shifts"""+ ValidationUtils.validate_positive(yield_shift, "Yield shift")++ # Calculate prices with up and down shifts+ up_curve = base_curve.shift_curve(yield_shift, "parallel")+ down_curve = base_curve.shift_curve(-yield_shift, "parallel")++ base_price = BondValuation.present_value_with_curve(bond, base_curve)+ up_price = BondValuation.present_value_with_curve(bond, up_curve)+ down_price = BondValuation.present_value_with_curve(bond, down_curve)++ # Convexity = (P+ + P- - 2*P0) / (P0 * (Δy)²)+ if base_price == 0:+ return Decimal('0')++ numerator = up_price + down_price - Decimal('2') * base_price+ denominator = base_price * (yield_shift ** 2)++ return numerator / denominator++ @staticmethod+ def convexity_adjustment(duration: Decimal, convexity: Decimal,+ yield_change: Decimal) -> Decimal:+ """Calculate convexity adjustment to duration-based price change"""+ return Decimal('0.5') * convexity * (yield_change ** 2)++ @staticmethod+ def approximate_price_change(duration: Decimal, convexity: Decimal,+ yield_change: Decimal) -> Decimal:+ """Approximate percentage price change using duration and convexity"""+ duration_effect = -duration * yield_change+ convexity_effect = ConvexityMeasures.convexity_adjustment(duration, convexity, yield_change)++ return duration_effect + convexity_effect+++class KeyRateDuration:+ """Key Rate Duration analysis for yield curve risk"""++ @staticmethod+ def calculate_key_rate_durations(bond: Bond, base_curve: SpotCurve,+ key_maturities: List[Decimal],+ yield_shift: Decimal = Decimal('0.0001')) -> Dict[Decimal, Decimal]:+ """Calculate key rate durations for specified maturities"""+ base_price = BondValuation.present_value_with_curve(bond, base_curve)+ key_durations = {}++ for maturity in key_maturities:+ # Create curve with shift only at this maturity+ shifted_curve = KeyRateDuration._create_key_rate_shifted_curve(+ base_curve, maturity, yield_shift+ )++ shifted_price = BondValuation.present_value_with_curve(bond, shifted_curve)++ # Key rate duration = -(ΔP/P) / Δy+ if base_price != 0:+ key_duration = -(shifted_price - base_price) / (base_price * yield_shift)+ else:+ key_duration = Decimal('0')++ key_durations[maturity] = key_duration++ return key_durations++ @staticmethod+ def _create_key_rate_shifted_curve(base_curve: SpotCurve, shift_maturity: Decimal,+ shift_amount: Decimal) -> SpotCurve:+ """Create curve with shift concentrated at specific maturity"""+ new_rates = []++ for i, maturity in enumerate(base_curve.curve.maturities):+ base_rate = base_curve.curve.rates[i]++ # Apply shift with triangular weighting around shift_maturity+ if abs(maturity - shift_maturity) <= Decimal('1'): # Within 1 year+ weight = Decimal('1') - abs(maturity - shift_maturity)+ shift = shift_amount * weight+ else:+ shift = Decimal('0')++ new_rates.append(base_rate + shift)++ from models import YieldCurve+ new_curve = YieldCurve(+ curve_date=base_curve.curve.curve_date,+ maturities=base_curve.curve.maturities.copy(),+ rates=new_rates,+ currency=base_curve.curve.currency,+ curve_type="spot"+ )++ from yield_curves import SpotCurve+ return SpotCurve(new_curve)+++class PortfolioRiskMetrics:+ """Portfolio-level risk calculations"""++ @staticmethod+ def portfolio_duration(portfolio: Portfolio, yields: Dict[str, Decimal],+ prices: Dict[str, Decimal]) -> Decimal:+ """Calculate portfolio duration as market-value weighted average"""+ total_market_value = Decimal('0')+ weighted_duration = Decimal('0')++ for bond, quantity in portfolio.holdings:+ bond_id = bond.isin++ if bond_id not in yields or bond_id not in prices:+ continue++ bond_yield = yields[bond_id]+ bond_price = prices[bond_id]+ market_value = bond_price * quantity++ duration = DurationMeasures.modified_duration(bond, bond_yield)++ total_market_value += market_value+ weighted_duration += duration * market_value++ if total_market_value == 0:+ return Decimal('0')++ return weighted_duration / total_market_value++ @staticmethod+ def portfolio_convexity(portfolio: Portfolio, base_curve: SpotCurve,+ prices: Dict[str, Decimal]) -> Decimal:+ """Calculate portfolio convexity as market-value weighted average"""+ total_market_value = Decimal('0')+ weighted_convexity = Decimal('0')++ for bond, quantity in portfolio.holdings:+ bond_id = bond.isin++ if bond_id not in prices:+ continue++ bond_price = prices[bond_id]+ market_value = bond_price * quantity++ convexity = ConvexityMeasures.effective_convexity(bond, base_curve)++ total_market_value += market_value+ weighted_convexity += convexity * market_value++ if total_market_value == 0:+ return Decimal('0')++ return weighted_convexity / total_market_value++ @staticmethod+ def duration_matching_error(portfolio: Portfolio, target_duration: Decimal,+ yields: Dict[str, Decimal], prices: Dict[str, Decimal]) -> Decimal:+ """Calculate duration matching error"""+ portfolio_dur = PortfolioRiskMetrics.portfolio_duration(portfolio, yields, prices)+ return portfolio_dur - target_duration++ @staticmethod+ def portfolio_yield(portfolio: Portfolio, yields: Dict[str, Decimal],+ prices: Dict[str, Decimal]) -> Decimal:+ """Calculate portfolio yield as market-value weighted average"""+ total_market_value = Decimal('0')+ weighted_yield = Decimal('0')++ for bond, quantity in portfolio.holdings:+ bond_id = bond.isin++ if bond_id not in yields or bond_id not in prices:+ continue++ bond_yield = yields[bond_id]+ bond_price = prices[bond_id]+ market_value = bond_price * quantity++ total_market_value += market_value+ weighted_yield += bond_yield * market_value++ if total_market_value == 0:+ return Decimal('0')++ return weighted_yield / total_market_value+++class ValueAtRisk:+ """Value at Risk calculations for fixed income portfolios"""++ @staticmethod+ def parametric_var(portfolio_value: Decimal, portfolio_duration: Decimal,+ yield_volatility: Decimal, confidence_level: Decimal = Decimal('0.95'),+ time_horizon: Decimal = Decimal('1')) -> Decimal:+ """Calculate parametric VaR using duration approximation"""+ ValidationUtils.validate_positive(portfolio_value, "Portfolio value")+ ValidationUtils.validate_positive(yield_volatility, "Yield volatility")+ ValidationUtils.validate_percentage(confidence_level, "Confidence level")++ # Standard normal quantile for confidence level+ if confidence_level == Decimal('0.95'):+ z_score = Decimal('1.645') # 95% confidence+ elif confidence_level == Decimal('0.99'):+ z_score = Decimal('2.326') # 99% confidence+ else:+ # Approximate for other confidence levels+ z_score = Decimal('1.645') # Default to 95%++ # VaR = Portfolio Value × Duration × Yield Volatility × Z-score × √(Time Horizon)+ time_factor = time_horizon ** Decimal('0.5')+ var = portfolio_value * portfolio_duration * yield_volatility * z_score * time_factor++ return var++ @staticmethod+ def monte_carlo_var(portfolio: Portfolio, base_curve: SpotCurve,+ yield_volatility: Decimal, simulations: int = 10000,+ confidence_level: Decimal = Decimal('0.95'),+ time_horizon: Decimal = Decimal('1')) -> Tuple[Decimal, List[Decimal]]:+ """Calculate VaR using Monte Carlo simulation"""+ import random++ current_value = Decimal('0')+ simulated_values = []++ # Calculate current portfolio value+ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, base_curve)+ current_value += bond_value * quantity++ # Run Monte Carlo simulations+ for _ in range(simulations):+ # Generate random yield change+ random_change = Decimal(str(random.gauss(0, float(yield_volatility * (time_horizon ** Decimal('0.5'))))))++ # Shift curve and revalue portfolio+ shifted_curve = base_curve.shift_curve(random_change, "parallel")+ portfolio_value = Decimal('0')++ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, shifted_curve)+ portfolio_value += bond_value * quantity++ value_change = portfolio_value - current_value+ simulated_values.append(value_change)++ # Calculate VaR as percentile+ simulated_values.sort()+ var_index = int((1 - confidence_level) * simulations)+ var = -simulated_values[var_index] # VaR is positive number representing loss++ return var, simulated_values+++class StressTestingFramework:+ """Stress testing framework for fixed income portfolios"""++ @staticmethod+ def parallel_shift_stress_test(portfolio: Portfolio, base_curve: SpotCurve,+ stress_scenarios: List[Decimal]) -> Dict[str, Dict]:+ """Stress test portfolio under parallel yield curve shifts"""+ base_value = Decimal('0')++ # Calculate base case value+ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, base_curve)+ base_value += bond_value * quantity++ results = {'base_case': {'value': base_value, 'change': Decimal('0'), 'change_pct': Decimal('0')}}++ for shift in stress_scenarios:+ stressed_curve = base_curve.shift_curve(shift, "parallel")+ stressed_value = Decimal('0')++ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, stressed_curve)+ stressed_value += bond_value * quantity++ change = stressed_value - base_value+ change_pct = (change / base_value * Decimal('100')) if base_value != 0 else Decimal('0')++ scenario_name = f"shift_{shift * 10000:.0f}bp"+ results[scenario_name] = {+ 'value': stressed_value,+ 'change': change,+ 'change_pct': change_pct+ }++ return results++ @staticmethod+ def yield_curve_scenario_analysis(portfolio: Portfolio, base_curve: SpotCurve,+ scenarios: Dict[str, str]) -> Dict[str, Dict]:+ """Analyze portfolio under different yield curve scenarios"""+ base_value = Decimal('0')++ # Calculate base case value+ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, base_curve)+ base_value += bond_value * quantity++ results = {'base_case': {'value': base_value, 'change': Decimal('0'), 'change_pct': Decimal('0')}}++ for scenario_name, scenario_type in scenarios.items():+ if scenario_type == "steepening":+ stressed_curve = base_curve.shift_curve(Decimal('0.01'), "steepening")+ elif scenario_type == "flattening":+ stressed_curve = base_curve.shift_curve(Decimal('0.01'), "flattening")+ elif scenario_type == "bear_steepening":+ # Rates up more at long end+ stressed_curve = base_curve.shift_curve(Decimal('0.005'), "parallel")+ stressed_curve = stressed_curve.shift_curve(Decimal('0.005'), "steepening")+ elif scenario_type == "bull_flattening":+ # Rates down more at long end+ stressed_curve = base_curve.shift_curve(Decimal('-0.005'), "parallel")+ stressed_curve = stressed_curve.shift_curve(Decimal('0.005'), "flattening")+ else:+ continue++ stressed_value = Decimal('0')+ for bond, quantity in portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, stressed_curve)+ stressed_value += bond_value * quantity++ change = stressed_value - base_value+ change_pct = (change / base_value * Decimal('100')) if base_value != 0 else Decimal('0')++ results[scenario_name] = {+ 'value': stressed_value,+ 'change': change,+ 'change_pct': change_pct+ }++ return results+++class HedgingAnalytics:+ """Hedging calculations and analytics"""++ @staticmethod+ def duration_hedge_ratio(target_bond: Bond, hedge_bond: Bond,+ target_duration: Decimal, hedge_duration: Decimal) -> Decimal:+ """Calculate hedge ratio for duration hedging"""+ if hedge_duration == 0:+ return Decimal('0')++ return target_duration / hedge_duration++ @staticmethod+ def optimal_hedge_portfolio(target_portfolio: Portfolio, hedge_instruments: List[Bond],+ base_curve: SpotCurve) -> Dict[str, Decimal]:+ """Calculate optimal hedge portfolio weights (simplified)"""+ # Calculate target portfolio duration+ target_duration = Decimal('0')+ target_value = Decimal('0')++ for bond, quantity in target_portfolio.holdings:+ bond_value = BondValuation.present_value_with_curve(bond, base_curve)+ bond_duration = DurationMeasures.effective_duration(bond, base_curve)++ position_value = bond_value * quantity+ target_value += position_value+ target_duration += bond_duration * position_value++ if target_value != 0:+ target_duration = target_duration / target_value++ # Simple two-instrument hedge (e.g., short and long duration instruments)+ if len(hedge_instruments) >= 2:+ short_bond = hedge_instruments[0]+ long_bond = hedge_instruments[1]++ short_duration = DurationMeasures.effective_duration(short_bond, base_curve)+ long_duration = DurationMeasures.effective_duration(long_bond, base_curve)++ # Solve for weights to achieve zero portfolio duration+ # w1 * d1 + w2 * d2 = -target_duration (to offset)+ # w1 + w2 = 1 (budget constraint, simplified)++ if long_duration != short_duration:+ w2 = (-target_duration - short_duration) / (long_duration - short_duration)+ w1 = Decimal('1') - w2++ return {+ short_bond.isin: w1,+ long_bond.isin: w2+ }++ return {}+++# Utility functions for risk reporting+def generate_risk_report(portfolio: Portfolio, base_curve: SpotCurve,+ yields: Dict[str, Decimal], prices: Dict[str, Decimal]) -> Dict:+ """Generate comprehensive risk report for portfolio"""++ # Basic metrics+ portfolio_dur = PortfolioRiskMetrics.portfolio_duration(portfolio, yields, prices)+ portfolio_conv = PortfolioRiskMetrics.portfolio_convexity(portfolio, base_curve, prices)+ portfolio_yld = PortfolioRiskMetrics.portfolio_yield(portfolio, yields, prices)++ # Calculate total portfolio value+ total_value = Decimal('0')+ for bond, quantity in portfolio.holdings:+ if bond.isin in prices:+ total_value += prices[bond.isin] * quantity++ # VaR calculation+ yield_vol = Decimal('0.01') # Assume 1% daily yield volatility+ var_95 = ValueAtRisk.parametric_var(total_value, portfolio_dur, yield_vol, Decimal('0.95'))+ var_99 = ValueAtRisk.parametric_var(total_value, portfolio_dur, yield_vol, Decimal('0.99'))++ # Stress tests+ stress_scenarios = [Decimal('-0.02'), Decimal('-0.01'), Decimal('0.01'), Decimal('0.02')] # ±100bp, ±200bp+ stress_results = StressTestingFramework.parallel_shift_stress_test(portfolio, base_curve, stress_scenarios)++ return {+ 'portfolio_metrics': {+ 'duration': portfolio_dur,+ 'convexity': portfolio_conv,+ 'yield': portfolio_yld,+ 'total_value': total_value+ },+ 'risk_metrics': {+ 'var_95': var_95,+ 'var_99': var_99+ },+ 'stress_test_results': stress_results+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/term_structure.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/term_structure.pynew file mode 100644index 000000000..8a61b1693--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/term_structure.py@@ -0,0 +1,660 @@++Fixed Income Term Structure Module+=================================++Yield curve and term structure modeling++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Dict, Optional, Tuple, Callable+from decimal import Decimal+from datetime import date+import math+from models import YieldCurve+from yield_curves import SpotCurve, ForwardCurve+from utils import MathUtils, DateUtils, ValidationUtils, cache_calculation+from config import Currency, ERROR_TOLERANCE++class TermStructureTheories:+ """Implementation of classical term structure theories"""++ @staticmethod+ def pure_expectations_theory(forward_rates: List[Decimal],+ maturities: List[Decimal]) -> Dict[str, Decimal]:+ """Analyze yield curve under Pure Expectations Theory"""+ if len(forward_rates) != len(maturities):+ raise ValueError("Forward rates and maturities must have same length")++ # Under PET: Long-term rates = geometric average of expected short rates+ # No liquidity premium, risk premium = 0++ results = {}++ for i, maturity in enumerate(maturities):+ if i == 0:+ spot_rate = forward_rates[i]+ else:+ # Geometric average of forward rates+ product = Decimal('1')+ for j in range(i + 1):+ product *= (Decimal('1') + forward_rates[j])++ spot_rate = product ** (Decimal('1') / Decimal(str(i + 1))) - Decimal('1')++ results[f"spot_rate_{maturity}Y"] = spot_rate+ results[f"forward_rate_{maturity}Y"] = forward_rates[i]++ # Calculate implied risk premiums (should be zero under PET)+ results['liquidity_premiums'] = [Decimal('0')] * len(maturities)+ results['theory'] = 'Pure Expectations Theory'+ results['risk_premium_assumption'] = 'Zero risk premiums'++ return results++ @staticmethod+ def liquidity_preference_theory(forward_rates: List[Decimal],+ maturities: List[Decimal],+ liquidity_premiums: List[Decimal]) -> Dict[str, Decimal]:+ """Analyze yield curve under Liquidity Preference Theory"""+ if len(forward_rates) != len(maturities) or len(liquidity_premiums) != len(maturities):+ raise ValueError("All input lists must have same length")++ # Under LPT: Forward rates = Expected future rates + Liquidity premium+ # Liquidity premiums increase with maturity++ results = {}++ # Adjust forward rates for liquidity premiums+ expected_rates = []+ for i in range(len(forward_rates)):+ expected_rate = forward_rates[i] - liquidity_premiums[i]+ expected_rates.append(expected_rate)++ # Calculate spot rates incorporating liquidity premiums+ for i, maturity in enumerate(maturities):+ if i == 0:+ spot_rate = forward_rates[i]+ else:+ # Geometric average including liquidity premiums+ product = Decimal('1')+ for j in range(i + 1):+ product *= (Decimal('1') + forward_rates[j])++ spot_rate = product ** (Decimal('1') / Decimal(str(i + 1))) - Decimal('1')++ results[f"spot_rate_{maturity}Y"] = spot_rate+ results[f"expected_rate_{maturity}Y"] = expected_rates[i]+ results[f"liquidity_premium_{maturity}Y"] = liquidity_premiums[i]++ results['theory'] = 'Liquidity Preference Theory'+ results['risk_premium_assumption'] = 'Positive, increasing liquidity premiums'++ return results++ @staticmethod+ def market_segmentation_theory(supply_demand_factors: Dict[Decimal, Dict[str, Decimal]]) -> Dict[str, Decimal]:+ """Analyze yield curve under Market Segmentation Theory"""+ # Under MST: Rates determined by supply/demand in each maturity segment+ # Limited arbitrage between segments++ results = {}+ results['theory'] = 'Market Segmentation Theory'++ for maturity, factors in supply_demand_factors.items():+ supply = factors.get('supply', Decimal('1'))+ demand = factors.get('demand', Decimal('1'))+ base_rate = factors.get('base_rate', Decimal('0.03'))++ # Simple supply/demand impact on rates+ # Higher supply relative to demand → higher rates+ supply_demand_ratio = supply / demand if demand > 0 else Decimal('1')++ # Rate adjustment based on supply/demand imbalance+ rate_adjustment = (supply_demand_ratio - Decimal('1')) * Decimal('0.01') # 1% per unit imbalance+ adjusted_rate = base_rate + rate_adjustment++ results[f"rate_{maturity}Y"] = adjusted_rate+ results[f"supply_demand_ratio_{maturity}Y"] = supply_demand_ratio+ results[f"rate_adjustment_{maturity}Y"] = rate_adjustment++ results['arbitrage_assumption'] = 'Limited arbitrage between maturity segments'++ return results++ @staticmethod+ def preferred_habitat_theory(forward_rates: List[Decimal],+ maturities: List[Decimal],+ habitat_premiums: List[Decimal]) -> Dict[str, Decimal]:+ """Analyze yield curve under Preferred Habitat Theory"""+ if len(forward_rates) != len(maturities) or len(habitat_premiums) != len(maturities):+ raise ValueError("All input lists must have same length")++ # Under PHT: Combination of expectations and preferred habitats+ # Risk premiums can be positive or negative based on habitat preferences++ results = {}++ # Expected rates = Forward rates - Habitat premiums+ expected_rates = []+ for i in range(len(forward_rates)):+ expected_rate = forward_rates[i] - habitat_premiums[i]+ expected_rates.append(expected_rate)++ # Calculate spot rates+ for i, maturity in enumerate(maturities):+ if i == 0:+ spot_rate = forward_rates[i]+ else:+ product = Decimal('1')+ for j in range(i + 1):+ product *= (Decimal('1') + forward_rates[j])++ spot_rate = product ** (Decimal('1') / Decimal(str(i + 1))) - Decimal('1')++ results[f"spot_rate_{maturity}Y"] = spot_rate+ results[f"expected_rate_{maturity}Y"] = expected_rates[i]+ results[f"habitat_premium_{maturity}Y"] = habitat_premiums[i]++ results['theory'] = 'Preferred Habitat Theory'+ results['risk_premium_assumption'] = 'Risk premiums can be positive or negative'++ return results++class YieldCurveFactors:+ """Yield curve factor analysis and decomposition"""++ @staticmethod+ def level_slope_curvature_factors(spot_curve: SpotCurve,+ key_maturities: List[Decimal] = None) -> Dict[str, Decimal]:+ """Decompose yield curve into level, slope, and curvature factors"""+ if key_maturities is None:+ key_maturities = [Decimal('2'), Decimal('5'), Decimal('10')]++ if len(key_maturities) < 3:+ raise ValueError("Need at least 3 maturities for LSC decomposition")++ # Get rates for key maturities+ rates = [spot_curve.get_rate(maturity) for maturity in key_maturities]++ # Level: Average of all rates+ level = sum(rates) / Decimal(str(len(rates)))++ # Slope: Long rate - Short rate+ slope = rates[-1] - rates[0]++ # Curvature: 2 * Middle - Short - Long (butterfly)+ if len(rates) >= 3:+ curvature = Decimal('2') * rates[1] - rates[0] - rates[-1]+ else:+ curvature = Decimal('0')++ # Calculate factor loadings for all curve points+ factor_loadings = YieldCurveFactors._calculate_factor_loadings(spot_curve, key_maturities)++ return {+ 'level_factor': level,+ 'slope_factor': slope,+ 'curvature_factor': curvature,+ 'factor_loadings': factor_loadings,+ 'explained_variance': {+ 'level': Decimal('0.85'), # Typical values+ 'slope': Decimal('0.12'),+ 'curvature': Decimal('0.03')+ }+ }++ @staticmethod+ def _calculate_factor_loadings(spot_curve: SpotCurve,+ key_maturities: List[Decimal]) -> Dict[str, List[Decimal]]:+ """Calculate factor loadings for level, slope, curvature"""+ maturities = spot_curve.curve.maturities+ n = len(maturities)++ # Level loadings: Equal weight (1/√n for normalization)+ level_loadings = [Decimal('1') / (Decimal(str(n)) ** Decimal('0.5'))] * n++ # Slope loadings: Linear from -1 to +1+ slope_loadings = []+ for i, maturity in enumerate(maturities):+ # Normalize to [-1, +1] range+ loading = Decimal('-1') + Decimal('2') * Decimal(str(i)) / Decimal(str(n - 1))+ slope_loadings.append(loading)++ # Curvature loadings: Quadratic shape+ curvature_loadings = []+ for i, maturity in enumerate(maturities):+ # Quadratic: high at ends, low in middle+ x = Decimal(str(i)) / Decimal(str(n - 1)) # Normalize to [0, 1]+ loading = Decimal('2') * x * (Decimal('1') - x) # Parabolic shape+ curvature_loadings.append(loading)++ return {+ 'level': level_loadings,+ 'slope': slope_loadings,+ 'curvature': curvature_loadings+ }++ @staticmethod+ def principal_component_analysis(historical_curves: List[SpotCurve]) -> Dict[str, any]:+ """Simplified PCA analysis of yield curve movements"""+ if len(historical_curves) < 2:+ raise ValueError("Need at least 2 historical curves for PCA")++ # Get common maturities across all curves+ common_maturities = historical_curves[0].curve.maturities++ # Build rate matrix+ rate_matrix = []+ for curve in historical_curves:+ rates = [curve.get_rate(maturity) for maturity in common_maturities]+ rate_matrix.append(rates)++ # Calculate mean rates+ n_curves = len(rate_matrix)+ n_maturities = len(common_maturities)++ mean_rates = []+ for j in range(n_maturities):+ mean_rate = sum(rate_matrix[i][j] for i in range(n_curves)) / Decimal(str(n_curves))+ mean_rates.append(mean_rate)++ # Calculate rate changes (demeaned)+ rate_changes = []+ for i in range(n_curves):+ changes = [rate_matrix[i][j] - mean_rates[j] for j in range(n_maturities)]+ rate_changes.append(changes)++ # Simplified factor extraction (first 3 components)+ # In practice, would use proper eigenvalue decomposition++ # First component: level (average change)+ pc1_loadings = [Decimal('1') / (Decimal(str(n_maturities)) ** Decimal('0.5'))] * n_maturities++ # Second component: slope (linear)+ pc2_loadings = []+ for j in range(n_maturities):+ loading = Decimal('-1') + Decimal('2') * Decimal(str(j)) / Decimal(str(n_maturities - 1))+ pc2_loadings.append(loading)++ # Third component: curvature (quadratic)+ pc3_loadings = []+ for j in range(n_maturities):+ x = Decimal(str(j)) / Decimal(str(n_maturities - 1))+ loading = Decimal('2') * x * (Decimal('1') - x)+ pc3_loadings.append(loading)++ return {+ 'principal_components': {+ 'PC1_loadings': pc1_loadings,+ 'PC2_loadings': pc2_loadings,+ 'PC3_loadings': pc3_loadings+ },+ 'explained_variance': [Decimal('0.85'), Decimal('0.12'), Decimal('0.03')],+ 'interpretation': ['Level', 'Slope', 'Curvature'],+ 'mean_rates': mean_rates,+ 'maturities': common_maturities+ }++class VolatilityStructure:+ """Term structure of volatility analysis"""++ @staticmethod+ def yield_volatility_structure(historical_yields: Dict[Decimal, List[Decimal]],+ window_size: int = 252) -> Dict[Decimal, Dict[str, Decimal]]:+ """Calculate volatility structure across maturities"""+ volatility_structure = {}++ for maturity, yield_series in historical_yields.items():+ if len(yield_series) < window_size:+ continue++ # Calculate returns+ returns = []+ for i in range(1, len(yield_series)):+ return_val = yield_series[i] - yield_series[i-1]+ returns.append(return_val)++ # Rolling volatility+ volatilities = VolatilityStructure._calculate_rolling_volatility(returns, window_size)++ # Summary statistics+ if volatilities:+ avg_volatility = sum(volatilities) / Decimal(str(len(volatilities)))+ max_volatility = max(volatilities)+ min_volatility = min(volatilities)++ volatility_structure[maturity] = {+ 'average_volatility': avg_volatility,+ 'maximum_volatility': max_volatility,+ 'minimum_volatility': min_volatility,+ 'current_volatility': volatilities[-1] if volatilities else Decimal('0')+ }++ return volatility_structure++ @staticmethod+ def _calculate_rolling_volatility(returns: List[Decimal], window: int) -> List[Decimal]:+ """Calculate rolling volatility"""+ volatilities = []++ for i in range(window, len(returns) + 1):+ window_returns = returns[i-window:i]++ # Calculate mean+ mean_return = sum(window_returns) / Decimal(str(len(window_returns)))++ # Calculate variance+ variance = sum((r - mean_return) ** 2 for r in window_returns) / Decimal(str(len(window_returns) - 1))++ # Annualized volatility (assuming daily data)+ volatility = (variance ** Decimal('0.5')) * (Decimal('252') ** Decimal('0.5'))+ volatilities.append(volatility)++ return volatilities++ @staticmethod+ def volatility_smile_analysis(option_data: Dict[Decimal, Decimal]) -> Dict[str, Decimal]:+ """Analyze volatility smile/skew patterns"""+ # option_data: {strike: implied_volatility}++ if len(option_data) < 3:+ return {'error': 'Insufficient data for smile analysis'}++ strikes = sorted(option_data.keys())+ volatilities = [option_data[strike] for strike in strikes]++ # Find ATM volatility (middle strike)+ atm_index = len(strikes) // 2+ atm_vol = volatilities[atm_index]++ # Calculate skew metrics+ if len(strikes) >= 3:+ # 25-delta skew (approximated as 25% and 75% percentile strikes)+ low_strike_idx = len(strikes) // 4+ high_strike_idx = 3 * len(strikes) // 4++ skew_25d = volatilities[low_strike_idx] - volatilities[high_strike_idx]+ else:+ skew_25d = Decimal('0')++ # Butterfly (wings vs body)+ if len(strikes) >= 3:+ butterfly = (volatilities[0] + volatilities[-1]) / Decimal('2') - atm_vol+ else:+ butterfly = Decimal('0')++ return {+ 'atm_volatility': atm_vol,+ 'volatility_skew_25d': skew_25d,+ 'volatility_butterfly': butterfly,+ 'min_volatility': min(volatilities),+ 'max_volatility': max(volatilities),+ 'volatility_range': max(volatilities) - min(volatilities)+ }++ @staticmethod+ def term_structure_volatility_models(forward_rates: List[Decimal],+ volatilities: List[Decimal],+ model_type: str = 'ho_lee') -> Dict[str, any]:+ """Implement term structure volatility models"""+ if len(forward_rates) != len(volatilities):+ raise ValueError("Forward rates and volatilities must have same length")++ if model_type == 'ho_lee':+ return VolatilityStructure._ho_lee_model(forward_rates, volatilities)+ elif model_type == 'hull_white':+ return VolatilityStructure._hull_white_model(forward_rates, volatilities)+ elif model_type == 'black_karasinski':+ return VolatilityStructure._black_karasinski_model(forward_rates, volatilities)+ else:+ raise ValueError(f"Unknown model type: {model_type}")++ @staticmethod+ def _ho_lee_model(forward_rates: List[Decimal], volatilities: List[Decimal]) -> Dict[str, any]:+ """Ho-Lee model: dr = θ(t)dt + σdW"""+ # Constant volatility, drift adjusts to fit term structure++ avg_volatility = sum(volatilities) / Decimal(str(len(volatilities)))++ # Drift function to fit forward curve+ drift_function = []+ for i, rate in enumerate(forward_rates):+ if i == 0:+ drift = rate+ else:+ # Simplified drift calculation+ drift = forward_rates[i] - forward_rates[i-1]+ drift_function.append(drift)++ return {+ 'model': 'Ho-Lee',+ 'constant_volatility': avg_volatility,+ 'drift_function': drift_function,+ 'mean_reversion': Decimal('0'), # No mean reversion in Ho-Lee+ 'characteristics': 'Normal rates, constant volatility'+ }++ @staticmethod+ def _hull_white_model(forward_rates: List[Decimal], volatilities: List[Decimal]) -> Dict[str, any]:+ """Hull-White model: dr = [θ(t) - ar]dt + σdW"""+ # Mean-reverting with time-dependent drift++ avg_volatility = sum(volatilities) / Decimal(str(len(volatilities)))++ # Estimate mean reversion parameter (simplified)+ # In practice, would use maximum likelihood estimation+ mean_reversion = Decimal('0.1') # Typical value++ # Long-term mean (average of forward rates)+ long_term_mean = sum(forward_rates) / Decimal(str(len(forward_rates)))++ return {+ 'model': 'Hull-White',+ 'volatility': avg_volatility,+ 'mean_reversion_speed': mean_reversion,+ 'long_term_mean': long_term_mean,+ 'characteristics': 'Normal rates, mean-reverting'+ }++ @staticmethod+ def _black_karasinski_model(forward_rates: List[Decimal], volatilities: List[Decimal]) -> Dict[str, any]:+ """Black-Karasinski model: d(ln r) = [θ(t) - a ln r]dt + σdW"""+ # Log-normal rates, mean-reverting++ avg_volatility = sum(volatilities) / Decimal(str(len(volatilities)))++ # Transform rates to log space+ log_rates = [Decimal(str(math.log(float(rate)))) for rate in forward_rates if rate > 0]++ if log_rates:+ avg_log_rate = sum(log_rates) / Decimal(str(len(log_rates)))+ mean_reversion = Decimal('0.15') # Typical value for log-normal model+ else:+ avg_log_rate = Decimal('0')+ mean_reversion = Decimal('0')++ return {+ 'model': 'Black-Karasinski',+ 'volatility': avg_volatility,+ 'mean_reversion_speed': mean_reversion,+ 'mean_log_rate': avg_log_rate,+ 'characteristics': 'Log-normal rates, mean-reverting'+ }++class RidingTheYieldCurve:+ """Yield curve riding strategies and analysis"""++ @staticmethod+ def rolling_yield_analysis(bond_maturity: Decimal, holding_period: Decimal,+ spot_curve: SpotCurve) -> Dict[str, Decimal]:+ """Analyze rolling yield for bond investment"""+ ValidationUtils.validate_positive(bond_maturity, "Bond maturity")+ ValidationUtils.validate_positive(holding_period, "Holding period")++ if holding_period >= bond_maturity:+ raise ValueError("Holding period must be less than bond maturity")++ # Current yield+ current_yield = spot_curve.get_rate(bond_maturity)++ # Future maturity after holding period+ future_maturity = bond_maturity - holding_period++ # Expected future yield (rolling down the curve)+ if future_maturity > 0:+ future_yield = spot_curve.get_rate(future_maturity)+ else:+ future_yield = Decimal('0') # Bond matures++ # Rolling yield calculation+ # Assumes bond price moves along the yield curve++ # Current bond price (assume par)+ current_price = Decimal('100')++ # Future bond price if yield curve unchanged+ if future_maturity > 0:+ # Simplified price calculation+ future_price = current_price * (Decimal('1') + current_yield) / (Decimal('1') + future_yield)+ else:+ future_price = Decimal('100') # Matures at par++ # Total return components+ coupon_income = current_yield * holding_period * current_price+ capital_gain = future_price - current_price+ total_return = coupon_income + capital_gain++ # Annualized rolling yield+ if holding_period > 0:+ rolling_yield = total_return / (current_price * holding_period)+ else:+ rolling_yield = Decimal('0')++ return {+ 'current_yield': current_yield,+ 'future_yield': future_yield,+ 'yield_change': future_yield - current_yield,+ 'current_price': current_price,+ 'future_price': future_price,+ 'capital_gain': capital_gain,+ 'coupon_income': coupon_income,+ 'total_return': total_return,+ 'rolling_yield': rolling_yield,+ 'excess_return': rolling_yield - current_yield+ }++ @staticmethod+ def optimal_maturity_selection(target_holding_period: Decimal,+ spot_curve: SpotCurve,+ maturity_range: Tuple[Decimal, Decimal] = (Decimal('1'), Decimal('30'))) -> Dict[str, Decimal]:+ """Find optimal bond maturity for yield curve riding"""+ ValidationUtils.validate_positive(target_holding_period, "Target holding period")++ min_maturity, max_maturity = maturity_range++ # Test different maturities+ test_maturities = []+ current_mat = min_maturity+ while current_mat <= max_maturity:+ if current_mat > target_holding_period: # Must be longer than holding period+ test_maturities.append(current_mat)+ current_mat += Decimal('0.5') # 6-month increments++ best_maturity = None+ best_rolling_yield = Decimal('-999')+ results = {}++ for maturity in test_maturities:+ try:+ analysis = RidingTheYieldCurve.rolling_yield_analysis(+ maturity, target_holding_period, spot_curve+ )++ rolling_yield = analysis['rolling_yield']+ results[f"maturity_{maturity}Y"] = {+ 'rolling_yield': rolling_yield,+ 'excess_return': analysis['excess_return'],+ 'yield_change': analysis['yield_change']+ }++ if rolling_yield > best_rolling_yield:+ best_rolling_yield = rolling_yield+ best_maturity = maturity++ except Exception:+ continue++ return {+ 'optimal_maturity': best_maturity,+ 'optimal_rolling_yield': best_rolling_yield,+ 'target_holding_period': target_holding_period,+ 'maturity_analysis': results+ }++# Utility functions for term structure analysis+def compare_term_structure_theories(spot_curve: SpotCurve,+ forward_curve: ForwardCurve) -> Dict[str, Dict]:+ """Compare different term structure theories"""++ maturities = [Decimal('1'), Decimal('2'), Decimal('5'), Decimal('10')]+ forward_rates = [forward_curve.get_forward_rate(Decimal('0'), mat) for mat in maturities]++ # Generate example premiums for different theories+ liquidity_premiums = [Decimal('0.001') * mat for mat in maturities] # Increasing with maturity+ habitat_premiums = [Decimal('0.0005') * (Decimal('1') if i % 2 == 0 else Decimal('-1'))+ for i, mat in enumerate(maturities)] # Alternating signs++ theories = {+ 'pure_expectations': TermStructureTheories.pure_expectations_theory(forward_rates, maturities),+ 'liquidity_preference': TermStructureTheories.liquidity_preference_theory(forward_rates, maturities, liquidity_premiums),+ 'preferred_habitat': TermStructureTheories.preferred_habitat_theory(forward_rates, maturities, habitat_premiums)+ }++ return theories++def yield_curve_scenario_analysis(base_curve: SpotCurve,+ scenarios: Dict[str, Dict[str, Decimal]]) -> Dict[str, Dict]:+ """Analyze yield curve under different scenarios"""++ results = {}++ # Base case analysis+ base_factors = YieldCurveFactors.level_slope_curvature_factors(base_curve)+ results['base_case'] = base_factors++ # Scenario analysis+ for scenario_name, shifts in scenarios.items():+ shift_type = shifts.get('type', 'parallel')+ shift_amount = shifts.get('amount', Decimal('0.01'))++ shifted_curve = base_curve.shift_curve(shift_amount, shift_type)+ scenario_factors = YieldCurveFactors.level_slope_curvature_factors(shifted_curve)++ results[scenario_name] = {+ 'factors': scenario_factors,+ 'shift_type': shift_type,+ 'shift_amount': shift_amount+ }++ return results\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/utils.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/utils.pynew file mode 100644index 000000000..53e4782c6--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/utils.py@@ -0,0 +1,625 @@++Fixed Income Utils Module+=================================++Fixed income utility functions++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++import math+from typing import Callable, Optional, List, Tuple, Union+from decimal import Decimal, getcontext+from datetime import date, datetime, timedelta+from config import (+ DayCountConvention, CompoundingFrequency, BusinessDayConvention,+ PRECISION_CONFIG, ERROR_TOLERANCE, ValidationError+)++# Set high precision for calculations+getcontext().prec = 28+++class MathUtils:+ """Mathematical utility functions for fixed income calculations"""++ @staticmethod+ def newton_raphson(func: Callable[[Decimal], Decimal],+ derivative: Callable[[Decimal], Decimal],+ initial_guess: Decimal,+ tolerance: Decimal = ERROR_TOLERANCE['medium'],+ max_iterations: int = 100) -> Decimal:+ """Newton-Raphson method for root finding"""+ x = initial_guess++ for i in range(max_iterations):+ fx = func(x)++ if abs(fx) < tolerance:+ return x++ dfx = derivative(x)+ if abs(dfx) < tolerance:+ raise ValueError("Derivative too small, convergence failed")++ x_new = x - fx / dfx++ if abs(x_new - x) < tolerance:+ return x_new++ x = x_new++ raise ValueError(f"Newton-Raphson failed to converge after {max_iterations} iterations")++ @staticmethod+ def bisection_method(func: Callable[[Decimal], Decimal],+ lower_bound: Decimal,+ upper_bound: Decimal,+ tolerance: Decimal = ERROR_TOLERANCE['medium'],+ max_iterations: int = 100) -> Decimal:+ """Bisection method for root finding"""+ if func(lower_bound) * func(upper_bound) > 0:+ raise ValueError("Function must have opposite signs at bounds")++ for i in range(max_iterations):+ midpoint = (lower_bound + upper_bound) / Decimal('2')+ f_mid = func(midpoint)++ if abs(f_mid) < tolerance or (upper_bound - lower_bound) / Decimal('2') < tolerance:+ return midpoint++ if func(lower_bound) * f_mid < 0:+ upper_bound = midpoint+ else:+ lower_bound = midpoint++ raise ValueError(f"Bisection method failed to converge after {max_iterations} iterations")++ @staticmethod+ def brent_method(func: Callable[[Decimal], Decimal],+ lower_bound: Decimal,+ upper_bound: Decimal,+ tolerance: Decimal = ERROR_TOLERANCE['medium'],+ max_iterations: int = 100) -> Decimal:+ """Brent's method for root finding (combines bisection and secant methods)"""+ a, b = lower_bound, upper_bound+ fa, fb = func(a), func(b)++ if fa * fb > 0:+ raise ValueError("Function must have opposite signs at bounds")++ if abs(fa) < abs(fb):+ a, b = b, a+ fa, fb = fb, fa++ c = a+ fc = fa+ mflag = True++ for i in range(max_iterations):+ if abs(fb) < tolerance:+ return b++ if fa != fc and fb != fc:+ # Inverse quadratic interpolation+ s = (a * fb * fc) / ((fa - fb) * (fa - fc)) + \+ (b * fa * fc) / ((fb - fa) * (fb - fc)) + \+ (c * fa * fb) / ((fc - fa) * (fc - fb))+ else:+ # Secant method+ s = b - fb * (b - a) / (fb - fa)++ # Check conditions for bisection+ condition1 = not ((Decimal('3') * a + b) / Decimal('4') <= s <= b)+ condition2 = mflag and abs(s - b) >= abs(b - c) / Decimal('2')+ condition3 = not mflag and abs(s - b) >= abs(c - d) / Decimal('2')+ condition4 = mflag and abs(b - c) < tolerance+ condition5 = not mflag and abs(c - d) < tolerance++ if condition1 or condition2 or condition3 or condition4 or condition5:+ s = (a + b) / Decimal('2')+ mflag = True+ else:+ mflag = False++ fs = func(s)+ d = c+ c = b+ fc = fb++ if fa * fs < 0:+ b = s+ fb = fs+ else:+ a = s+ fa = fs++ if abs(fa) < abs(fb):+ a, b = b, a+ fa, fb = fb, fa++ raise ValueError(f"Brent's method failed to converge after {max_iterations} iterations")++ @staticmethod+ def present_value(cash_flow: Decimal, discount_rate: Decimal, time_period: Decimal) -> Decimal:+ """Calculate present value of a cash flow"""+ if discount_rate < -1:+ raise ValueError("Discount rate cannot be less than -100%")++ return cash_flow / ((Decimal('1') + discount_rate) ** time_period)++ @staticmethod+ def future_value(present_value: Decimal, rate: Decimal, time_period: Decimal) -> Decimal:+ """Calculate future value"""+ return present_value * ((Decimal('1') + rate) ** time_period)++ @staticmethod+ def compound_frequency_conversion(rate: Decimal,+ from_freq: CompoundingFrequency,+ to_freq: CompoundingFrequency) -> Decimal:+ """Convert rate between different compounding frequencies"""+ if from_freq == to_freq:+ return rate++ # Convert to continuous compounding first+ if from_freq == CompoundingFrequency.CONTINUOUS:+ continuous_rate = rate+ else:+ m = Decimal(str(from_freq.value))+ continuous_rate = m * Decimal(str(math.log(float(1 + rate / m))))++ # Convert from continuous to target frequency+ if to_freq == CompoundingFrequency.CONTINUOUS:+ return continuous_rate+ else:+ n = Decimal(str(to_freq.value))+ return n * (Decimal(str(math.exp(float(continuous_rate / n)))) - Decimal('1'))++ @staticmethod+ def linear_interpolation(x: Decimal, x1: Decimal, y1: Decimal, x2: Decimal, y2: Decimal) -> Decimal:+ """Linear interpolation between two points"""+ if x1 == x2:+ return y1++ return y1 + (y2 - y1) * (x - x1) / (x2 - x1)++ @staticmethod+ def cubic_spline_interpolation(x: Decimal, points: List[Tuple[Decimal, Decimal]]) -> Decimal:+ """Simplified cubic spline interpolation (linear for now)"""+ # Find the two points to interpolate between+ points = sorted(points, key=lambda p: p[0])++ if x <= points[0][0]:+ return points[0][1]+ if x >= points[-1][0]:+ return points[-1][1]++ for i in range(len(points) - 1):+ if points[i][0] <= x <= points[i + 1][0]:+ return MathUtils.linear_interpolation(+ x, points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]+ )++ return points[0][1] # Fallback+++class DateUtils:+ """Date utility functions for fixed income calculations"""++ @staticmethod+ def add_business_days(start_date: date, business_days: int,+ convention: BusinessDayConvention = BusinessDayConvention.FOLLOWING) -> date:+ """Add business days to a date"""+ current_date = start_date+ days_added = 0++ while days_added < business_days:+ current_date += timedelta(days=1)+ if DateUtils.is_business_day(current_date):+ days_added += 1++ return DateUtils.adjust_for_business_day(current_date, convention)++ @staticmethod+ def is_business_day(check_date: date) -> bool:+ """Check if date is a business day (Monday-Friday, no holidays)"""+ # Simple implementation - excludes weekends only+ # In practice, would need holiday calendar+ return check_date.weekday() < 5++ @staticmethod+ def adjust_for_business_day(check_date: date,+ convention: BusinessDayConvention) -> date:+ """Adjust date according to business day convention"""+ if DateUtils.is_business_day(check_date):+ return check_date++ if convention == BusinessDayConvention.FOLLOWING:+ while not DateUtils.is_business_day(check_date):+ check_date += timedelta(days=1)+ elif convention == BusinessDayConvention.PRECEDING:+ while not DateUtils.is_business_day(check_date):+ check_date -= timedelta(days=1)+ elif convention == BusinessDayConvention.MODIFIED_FOLLOWING:+ original_month = check_date.month+ while not DateUtils.is_business_day(check_date):+ check_date += timedelta(days=1)+ # If we moved to next month, use preceding instead+ if check_date.month != original_month:+ check_date = DateUtils.adjust_for_business_day(+ check_date.replace(day=1) - timedelta(days=1),+ BusinessDayConvention.PRECEDING+ )+ elif convention == BusinessDayConvention.MODIFIED_PRECEDING:+ original_month = check_date.month+ while not DateUtils.is_business_day(check_date):+ check_date -= timedelta(days=1)+ # If we moved to previous month, use following instead+ if check_date.month != original_month:+ check_date = DateUtils.adjust_for_business_day(+ check_date.replace(day=1),+ BusinessDayConvention.FOLLOWING+ )+ # UNADJUSTED returns the original date++ return check_date++ @staticmethod+ def calculate_day_count_fraction(start_date: date, end_date: date,+ convention: DayCountConvention) -> Decimal:+ """Calculate day count fraction between two dates"""+ if start_date >= end_date:+ return Decimal('0')++ if convention == DayCountConvention.ACTUAL_360:+ days = (end_date - start_date).days+ return Decimal(days) / Decimal('360')++ elif convention == DayCountConvention.ACTUAL_365:+ days = (end_date - start_date).days+ return Decimal(days) / Decimal('365')++ elif convention == DayCountConvention.ACTUAL_365_FIXED:+ days = (end_date - start_date).days+ return Decimal(days) / Decimal('365')++ elif convention == DayCountConvention.ACTUAL_ACTUAL:+ # ISDA Actual/Actual+ days = (end_date - start_date).days+ year_start = date(start_date.year, 1, 1)+ year_end = date(start_date.year + 1, 1, 1)+ days_in_year = (year_end - year_start).days+ return Decimal(days) / Decimal(days_in_year)++ elif convention == DayCountConvention.THIRTY_360:+ return DateUtils._thirty_360_fraction(start_date, end_date)++ elif convention == DayCountConvention.THIRTY_360_EUROPEAN:+ return DateUtils._thirty_360_european_fraction(start_date, end_date)++ else:+ # Default to Actual/365+ days = (end_date - start_date).days+ return Decimal(days) / Decimal('365')++ @staticmethod+ def _thirty_360_fraction(start_date: date, end_date: date) -> Decimal:+ """Calculate 30/360 day count fraction (US/NASD convention)"""+ d1 = start_date.day+ d2 = end_date.day+ m1 = start_date.month+ m2 = end_date.month+ y1 = start_date.year+ y2 = end_date.year++ # Adjust for end-of-month+ if d1 == 31:+ d1 = 30+ if d1 == 30 and d2 == 31:+ d2 = 30++ days = 360 * (y2 - y1) + 30 * (m2 - m1) + (d2 - d1)+ return Decimal(days) / Decimal('360')++ @staticmethod+ def _thirty_360_european_fraction(start_date: date, end_date: date) -> Decimal:+ """Calculate 30E/360 day count fraction (European convention)"""+ d1 = min(start_date.day, 30)+ d2 = min(end_date.day, 30)+ m1 = start_date.month+ m2 = end_date.month+ y1 = start_date.year+ y2 = end_date.year++ days = 360 * (y2 - y1) + 30 * (m2 - m1) + (d2 - d1)+ return Decimal(days) / Decimal('360')++ @staticmethod+ def is_leap_year(year: int) -> bool:+ """Check if year is a leap year"""+ return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)++ @staticmethod+ def days_in_year(year: int) -> int:+ """Get number of days in a year"""+ return 366 if DateUtils.is_leap_year(year) else 365++ @staticmethod+ def end_of_month(input_date: date) -> date:+ """Get last day of month for given date"""+ if input_date.month == 12:+ next_month = date(input_date.year + 1, 1, 1)+ else:+ next_month = date(input_date.year, input_date.month + 1, 1)+ return next_month - timedelta(days=1)++ @staticmethod+ def generate_schedule(start_date: date, end_date: date,+ frequency: CompoundingFrequency,+ convention: BusinessDayConvention = BusinessDayConvention.MODIFIED_FOLLOWING) -> List[date]:+ """Generate payment schedule between two dates"""+ if frequency == CompoundingFrequency.CONTINUOUS:+ return [end_date] # Only final payment for continuous++ schedule = []+ freq_value = frequency.value+ months_between = 12 // freq_value++ current_date = end_date+ while current_date > start_date:+ schedule.append(DateUtils.adjust_for_business_day(current_date, convention))++ # Move back by payment frequency+ if current_date.month <= months_between:+ new_month = 12 + current_date.month - months_between+ new_year = current_date.year - 1+ else:+ new_month = current_date.month - months_between+ new_year = current_date.year++ try:+ current_date = current_date.replace(year=new_year, month=new_month)+ except ValueError:+ # Handle end-of-month adjustments+ current_date = DateUtils.end_of_month(date(new_year, new_month, 1))++ schedule.reverse()+ return schedule+++class ValidationUtils:+ """Input validation utilities"""++ @staticmethod+ def validate_positive(value: Decimal, name: str) -> Decimal:+ """Validate that value is positive"""+ if value <= 0:+ raise ValidationError(f"{name} must be positive, got {value}")+ return value++ @staticmethod+ def validate_non_negative(value: Decimal, name: str) -> Decimal:+ """Validate that value is non-negative"""+ if value < 0:+ raise ValidationError(f"{name} cannot be negative, got {value}")+ return value++ @staticmethod+ def validate_percentage(value: Decimal, name: str, allow_negative: bool = False) -> Decimal:+ """Validate percentage value (0-100% or -100% to 100%)"""+ min_val = Decimal('-1') if allow_negative else Decimal('0')+ max_val = Decimal('1')++ if not (min_val <= value <= max_val):+ raise ValidationError(f"{name} must be between {min_val * 100}% and {max_val * 100}%, got {value * 100}%")+ return value++ @staticmethod+ def validate_yield(value: Decimal, name: str = "Yield") -> Decimal:+ """Validate yield value"""+ from config import VALIDATION_RULES+ min_yield = VALIDATION_RULES['min_yield']+ max_yield = VALIDATION_RULES['max_yield']++ if not (min_yield <= value <= max_yield):+ raise ValidationError(+ f"{name} must be between {min_yield * 100}% and {max_yield * 100}%, got {value * 100}%")+ return value++ @staticmethod+ def validate_price(value: Decimal, name: str = "Price") -> Decimal:+ """Validate bond price"""+ from config import VALIDATION_RULES+ min_price = VALIDATION_RULES['min_price']+ max_price = VALIDATION_RULES['max_price']++ if not (min_price <= value <= max_price):+ raise ValidationError(f"{name} must be between {min_price} and {max_price}, got {value}")+ return value++ @staticmethod+ def validate_date_order(start_date: date, end_date: date,+ start_name: str = "Start date", end_name: str = "End date"):+ """Validate that start date is before end date"""+ if start_date >= end_date:+ raise ValidationError(f"{start_name} ({start_date}) must be before {end_name} ({end_date})")++ @staticmethod+ def validate_maturity_range(issue_date: date, maturity_date: date):+ """Validate maturity is within reasonable range"""+ from config import VALIDATION_RULES++ days_to_maturity = (maturity_date - issue_date).days+ min_days = VALIDATION_RULES['min_maturity_days']+ max_days = VALIDATION_RULES['max_maturity_years'] * 365++ if days_to_maturity < min_days:+ raise ValidationError(f"Maturity too short: {days_to_maturity} days (minimum: {min_days})")++ if days_to_maturity > max_days:+ raise ValidationError(f"Maturity too long: {days_to_maturity} days (maximum: {max_days})")+++class FormattingUtils:+ """Output formatting utilities"""++ @staticmethod+ def format_percentage(value: Decimal, decimal_places: int = 2) -> str:+ """Format decimal as percentage"""+ percentage = value * Decimal('100')+ return f"{percentage:.{decimal_places}f}%"++ @staticmethod+ def format_currency(value: Decimal, currency_symbol: str = "$", decimal_places: int = 2) -> str:+ """Format decimal as currency"""+ return f"{currency_symbol}{value:,.{decimal_places}f}"++ @staticmethod+ def format_basis_points(value: Decimal) -> str:+ """Format decimal as basis points"""+ bps = value * Decimal('10000')+ return f"{bps:.0f} bps"++ @staticmethod+ def format_yield(value: Decimal, decimal_places: int = 3) -> str:+ """Format yield with appropriate precision"""+ return FormattingUtils.format_percentage(value, decimal_places)++ @staticmethod+ def format_duration(value: Decimal, decimal_places: int = 2) -> str:+ """Format duration"""+ return f"{value:.{decimal_places}f} years"++ @staticmethod+ def format_price(value: Decimal, decimal_places: int = 4) -> str:+ """Format bond price"""+ return f"{value:.{decimal_places}f}"+++class CachingUtils:+ """Simple caching utilities for expensive calculations"""++ def __init__(self, max_size: int = 1000):+ self.cache = {}+ self.max_size = max_size+ self.access_order = []++ def get(self, key: str):+ """Get cached value"""+ if key in self.cache:+ # Move to end (most recently used)+ self.access_order.remove(key)+ self.access_order.append(key)+ return self.cache[key]+ return None++ def put(self, key: str, value):+ """Put value in cache"""+ if key in self.cache:+ # Update existing+ self.cache[key] = value+ self.access_order.remove(key)+ self.access_order.append(key)+ else:+ # Add new+ if len(self.cache) >= self.max_size:+ # Remove least recently used+ oldest_key = self.access_order.pop(0)+ del self.cache[oldest_key]++ self.cache[key] = value+ self.access_order.append(key)++ def clear(self):+ """Clear cache"""+ self.cache.clear()+ self.access_order.clear()+++# Global cache instance+calculation_cache = CachingUtils(max_size=5000)+++def cache_calculation(func):+ """Decorator for caching calculation results"""++ def wrapper(*args, **kwargs):+ # Create cache key from function name and arguments+ cache_key = f"{func.__name__}_{hash(str(args) + str(sorted(kwargs.items())))}"++ # Try to get from cache+ result = calculation_cache.get(cache_key)+ if result is not None:+ return result++ # Calculate and cache result+ result = func(*args, **kwargs)+ calculation_cache.put(cache_key, result)+ return result++ return wrapper+++# Commonly used mathematical constants as Decimals+PI = Decimal('3.1415926535897932384626433832795')+E = Decimal('2.7182818284590452353602874713527')+SQRT_2 = Decimal('1.4142135623730950488016887242097')+SQRT_2PI = Decimal('2.5066282746310005024157652848110')+++# Standard normal distribution approximation+def standard_normal_cdf(x: Decimal) -> Decimal:+ """Approximate standard normal cumulative distribution function"""+ # Abramowitz and Stegun approximation+ x_float = float(x)++ if x_float < 0:+ return Decimal('1') - standard_normal_cdf(-x)++ # Constants for approximation+ a1 = Decimal('0.254829592')+ a2 = Decimal('-0.284496736')+ a3 = Decimal('1.421413741')+ a4 = Decimal('-1.453152027')+ a5 = Decimal('1.061405429')+ p = Decimal('0.3275911')++ t = Decimal('1') / (Decimal('1') + p * x)+ y = Decimal('1') - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * \+ Decimal(str(math.exp(-float(x * x / Decimal('2')))))++ return y+++def black_scholes_call_price(S: Decimal, K: Decimal, T: Decimal, r: Decimal, sigma: Decimal) -> Decimal:+ """Black-Scholes call option price (simplified implementation)"""+ if T <= 0 or sigma <= 0:+ return max(S - K, Decimal('0'))++ d1 = (Decimal(str(math.log(float(S / K)))) + (r + sigma * sigma / Decimal('2')) * T) / (+ sigma * Decimal(str(math.sqrt(float(T)))))+ d2 = d1 - sigma * Decimal(str(math.sqrt(float(T))))++ call_price = S * standard_normal_cdf(d1) - K * Decimal(str(math.exp(-float(r * T)))) * standard_normal_cdf(d2)++ return call_price\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/valuation.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/valuation.pynew file mode 100644index 000000000..695703a65--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/valuation.py@@ -0,0 +1,616 @@++Fixed Income Valuation Module+=================================++Fixed income security valuation++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Dict, Optional, Tuple, Callable+from decimal import Decimal+from datetime import date+import random+from models import Bond, CallableBond, PutableBond, ConvertibleBond, CashFlow+from instruments import BondInstrument, create_bond_instrument+from yield_curves import SpotCurve+from utils import MathUtils, DateUtils, ValidationUtils, cache_calculation, black_scholes_call_price+from config import CompoundingFrequency, ERROR_TOLERANCE+++class BondValuation:+ """Basic bond valuation methods"""++ @staticmethod+ @cache_calculation+ def present_value(bond: Bond, discount_rate: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate present value of bond using single discount rate"""+ ValidationUtils.validate_yield(discount_rate, "Discount rate")++ if settlement_date is None:+ settlement_date = date.today()++ bond_instrument = create_bond_instrument(bond)+ cash_flows = bond_instrument.generate_cash_flows(settlement_date)++ total_pv = Decimal('0')++ for cf in cash_flows:+ time_to_payment = DateUtils.calculate_day_count_fraction(+ settlement_date, cf.date, bond.day_count_convention+ )++ pv = MathUtils.present_value(cf.amount, discount_rate, time_to_payment)+ total_pv += pv++ return total_pv++ @staticmethod+ def present_value_with_curve(bond: Bond, spot_curve: SpotCurve,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate present value using spot rate curve"""+ if settlement_date is None:+ settlement_date = date.today()++ bond_instrument = create_bond_instrument(bond)+ cash_flows = bond_instrument.generate_cash_flows(settlement_date)++ total_pv = Decimal('0')++ for cf in cash_flows:+ time_to_payment = DateUtils.calculate_day_count_fraction(+ settlement_date, cf.date, bond.day_count_convention+ )++ spot_rate = spot_curve.get_rate(time_to_payment)+ pv = MathUtils.present_value(cf.amount, spot_rate, time_to_payment)+ total_pv += pv++ return total_pv++ @staticmethod+ def yield_to_maturity(bond: Bond, price: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate yield to maturity using iterative methods"""+ ValidationUtils.validate_price(price, "Bond price")++ if settlement_date is None:+ settlement_date = date.today()++ # Define function: PV(ytm) - price = 0+ def price_function(ytm: Decimal) -> Decimal:+ pv = BondValuation.present_value(bond, ytm, settlement_date)+ return pv - price++ # Derivative of price function with respect to yield+ def price_derivative(ytm: Decimal) -> Decimal:+ # Numerical derivative using small increment+ delta = Decimal('0.0001')+ pv1 = BondValuation.present_value(bond, ytm - delta, settlement_date)+ pv2 = BondValuation.present_value(bond, ytm + delta, settlement_date)+ return (pv2 - pv1) / (Decimal('2') * delta)++ # Initial guess based on current yield+ if bond.coupon_rate > 0:+ initial_guess = bond.coupon_rate+ else:+ # For zero coupon bonds+ time_to_maturity = DateUtils.calculate_day_count_fraction(+ settlement_date, bond.maturity_date, bond.day_count_convention+ )+ initial_guess = (bond.face_value / price) ** (Decimal('1') / time_to_maturity) - Decimal('1')++ try:+ # Use Newton-Raphson method+ ytm = MathUtils.newton_raphson(price_function, price_derivative, initial_guess)+ ValidationUtils.validate_yield(ytm, "Yield to maturity")+ return ytm+ except:+ # Fallback to bisection method+ try:+ return MathUtils.bisection_method(price_function, Decimal('0.001'), Decimal('0.50'))+ except:+ # Last resort: Brent's method+ return MathUtils.brent_method(price_function, Decimal('0.001'), Decimal('0.50'))++ @staticmethod+ def current_yield(bond: Bond, price: Decimal) -> Decimal:+ """Calculate current yield (annual coupon / price)"""+ ValidationUtils.validate_price(price, "Bond price")++ if bond.is_zero_coupon:+ return Decimal('0')++ annual_coupon = bond.face_value * bond.coupon_rate+ return annual_coupon / price++ @staticmethod+ def accrued_interest(bond: Bond, settlement_date: date) -> Decimal:+ """Calculate accrued interest"""+ bond_instrument = create_bond_instrument(bond)+ return bond_instrument.accrued_interest(settlement_date)++ @staticmethod+ def clean_price(dirty_price: Decimal, accrued: Decimal) -> Decimal:+ """Calculate clean price from dirty price"""+ return dirty_price - accrued++ @staticmethod+ def dirty_price(clean_price: Decimal, accrued: Decimal) -> Decimal:+ """Calculate dirty price from clean price"""+ return clean_price + accrued+++class CallableBondValuation:+ """Valuation methods for callable bonds"""++ @staticmethod+ def yield_to_call(callable_bond: CallableBond, price: Decimal,+ call_date: date, call_price: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate yield to call"""+ ValidationUtils.validate_price(price, "Bond price")+ ValidationUtils.validate_price(call_price, "Call price")++ if settlement_date is None:+ settlement_date = date.today()++ # Create temporary bond with call date as maturity+ temp_bond = Bond(+ isin=callable_bond.isin + "_CALL",+ issue_date=callable_bond.issue_date,+ maturity_date=call_date,+ face_value=call_price, # Use call price as face value+ currency=callable_bond.currency,+ coupon_rate=callable_bond.coupon_rate,+ coupon_frequency=callable_bond.coupon_frequency,+ day_count_convention=callable_bond.day_count_convention+ )++ return BondValuation.yield_to_maturity(temp_bond, price, settlement_date)++ @staticmethod+ def yield_to_worst(callable_bond: CallableBond, price: Decimal,+ settlement_date: Optional[date] = None) -> Decimal:+ """Calculate yield to worst (minimum of YTM and all YTCs)"""+ if settlement_date is None:+ settlement_date = date.today()++ # Calculate YTM+ ytm = BondValuation.yield_to_maturity(callable_bond, price, settlement_date)++ yields = [ytm]++ # Calculate YTC for each call date+ for call_feature in callable_bond.call_schedule:+ if call_feature.call_date > settlement_date:+ ytc = CallableBondValuation.yield_to_call(+ callable_bond, price, call_feature.call_date,+ call_feature.call_price, settlement_date+ )+ yields.append(ytc)++ return min(yields)+++class ArbitrageFreeValuation:+ """Arbitrage-free valuation using binomial trees and Monte Carlo"""++ @staticmethod+ def binomial_tree_value(bond: Bond, spot_curve: SpotCurve, volatility: Decimal,+ steps: int = 100) -> Decimal:+ """Value bond using binomial interest rate tree"""+ ValidationUtils.validate_positive(volatility, "Volatility")+ ValidationUtils.validate_positive(Decimal(str(steps)), "Steps")++ time_to_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), bond.maturity_date, bond.day_count_convention+ )++ dt = time_to_maturity / Decimal(str(steps))++ # Build interest rate tree+ rate_tree = ArbitrageFreeValuation._build_rate_tree(+ spot_curve, volatility, steps, dt+ )++ # Generate bond cash flows+ bond_instrument = create_bond_instrument(bond)+ cash_flows = bond_instrument.generate_cash_flows()++ # Backward induction valuation+ return ArbitrageFreeValuation._backward_induction(+ rate_tree, cash_flows, bond, dt, steps+ )++ @staticmethod+ def _build_rate_tree(spot_curve: SpotCurve, volatility: Decimal,+ steps: int, dt: Decimal) -> List[List[Decimal]]:+ """Build binomial interest rate tree"""+ tree = []++ # Initial rate+ r0 = spot_curve.get_rate(dt)++ # Up and down factors+ u = Decimal(str(2.71828182845905)) ** (volatility * (dt ** Decimal('0.5')))+ d = Decimal('1') / u++ for i in range(steps + 1):+ level = []+ for j in range(i + 1):+ # Rate at node (i, j)+ rate = r0 * (u ** Decimal(str(j))) * (d ** Decimal(str(i - j)))+ level.append(rate)+ tree.append(level)++ return tree++ @staticmethod+ def _backward_induction(rate_tree: List[List[Decimal]], cash_flows: List[CashFlow],+ bond: Bond, dt: Decimal, steps: int) -> Decimal:+ """Perform backward induction on the tree"""+ # Create cash flow mapping by time step+ cf_map = {}+ for cf in cash_flows:+ time_to_cf = DateUtils.calculate_day_count_fraction(+ date.today(), cf.date, bond.day_count_convention+ )+ step = int(time_to_cf / dt)+ if step <= steps:+ cf_map[step] = cf_map.get(step, Decimal('0')) + cf.amount++ # Initialize final values+ values = [bond.face_value] * (steps + 1)++ # Work backwards through the tree+ for i in range(steps - 1, -1, -1):+ new_values = []+ for j in range(i + 1):+ # Discount expected value+ up_value = values[j + 1] if j + 1 < len(values) else bond.face_value+ down_value = values[j] if j < len(values) else bond.face_value++ expected_value = (up_value + down_value) / Decimal('2')+ discount_rate = rate_tree[i][j]++ discounted_value = expected_value / (Decimal('1') + discount_rate * dt)++ # Add any cash flow at this step+ if i in cf_map:+ discounted_value += cf_map[i]++ new_values.append(discounted_value)++ values = new_values++ return values[0] if values else bond.face_value++ @staticmethod+ def monte_carlo_value(bond: Bond, spot_curve: SpotCurve, volatility: Decimal,+ paths: int = 10000, steps: int = 252) -> Tuple[Decimal, Decimal]:+ """Value bond using Monte Carlo simulation"""+ ValidationUtils.validate_positive(volatility, "Volatility")+ ValidationUtils.validate_positive(Decimal(str(paths)), "Paths")++ time_to_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), bond.maturity_date, bond.day_count_convention+ )++ dt = time_to_maturity / Decimal(str(steps))++ # Generate bond cash flows+ bond_instrument = create_bond_instrument(bond)+ cash_flows = bond_instrument.generate_cash_flows()++ path_values = []++ for _ in range(paths):+ # Generate interest rate path+ rate_path = ArbitrageFreeValuation._generate_rate_path(+ spot_curve, volatility, steps, dt+ )++ # Value bond along this path+ path_value = ArbitrageFreeValuation._value_along_path(+ cash_flows, rate_path, bond, dt+ )+ path_values.append(path_value)++ # Calculate statistics+ mean_value = sum(path_values) / Decimal(str(len(path_values)))++ # Standard error+ variance = sum((v - mean_value) ** 2 for v in path_values) / Decimal(str(len(path_values) - 1))+ std_error = (variance / Decimal(str(len(path_values)))) ** Decimal('0.5')++ return mean_value, std_error++ @staticmethod+ def _generate_rate_path(spot_curve: SpotCurve, volatility: Decimal,+ steps: int, dt: Decimal) -> List[Decimal]:+ """Generate single interest rate path using Vasicek model"""+ path = []+ r = spot_curve.get_rate(dt) # Initial rate++ # Vasicek parameters (simplified)+ kappa = Decimal('0.1') # Mean reversion speed+ theta = spot_curve.get_rate(Decimal('10')) # Long-term mean++ for _ in range(steps):+ # Vasicek SDE: dr = kappa(theta - r)dt + sigma * dW+ drift = kappa * (theta - r) * dt+ shock = volatility * (dt ** Decimal('0.5')) * Decimal(str(random.gauss(0, 1)))++ r = r + drift + shock+ r = max(r, Decimal('0.0001')) # Floor at 1bp+ path.append(r)++ return path++ @staticmethod+ def _value_along_path(cash_flows: List[CashFlow], rate_path: List[Decimal],+ bond: Bond, dt: Decimal) -> Decimal:+ """Value bond along specific rate path"""+ total_value = Decimal('0')++ for cf in cash_flows:+ time_to_cf = DateUtils.calculate_day_count_fraction(+ date.today(), cf.date, bond.day_count_convention+ )++ # Find appropriate rate from path+ step = min(int(time_to_cf / dt), len(rate_path) - 1)+ discount_rate = rate_path[step]++ pv = MathUtils.present_value(cf.amount, discount_rate, time_to_cf)+ total_value += pv++ return total_value+++class OptionAdjustedSpread:+ """Option-Adjusted Spread (OAS) calculations"""++ @staticmethod+ def calculate_oas(bond: Bond, market_price: Decimal, spot_curve: SpotCurve,+ volatility: Decimal, steps: int = 100) -> Decimal:+ """Calculate Option-Adjusted Spread"""+ ValidationUtils.validate_price(market_price, "Market price")++ # Define function: Theoretical Price(OAS) - Market Price = 0+ def price_difference(oas: Decimal) -> Decimal:+ # Create shifted curve+ shifted_curve = spot_curve.shift_curve(oas, "parallel")++ # Value bond with shifted curve+ if isinstance(bond, (CallableBond, PutableBond)):+ theoretical_price = ArbitrageFreeValuation.binomial_tree_value(+ bond, shifted_curve, volatility, steps+ )+ else:+ theoretical_price = BondValuation.present_value_with_curve(+ bond, shifted_curve+ )++ return theoretical_price - market_price++ # Solve for OAS using bisection method+ try:+ oas = MathUtils.bisection_method(+ price_difference,+ Decimal('-0.05'), # -500 bps+ Decimal('0.05') # +500 bps+ )+ return oas+ except:+ # Fallback to wider range+ return MathUtils.bisection_method(+ price_difference,+ Decimal('-0.10'), # -1000 bps+ Decimal('0.10') # +1000 bps+ )++ @staticmethod+ def oas_duration(bond: Bond, market_price: Decimal, spot_curve: SpotCurve,+ volatility: Decimal, steps: int = 100) -> Decimal:+ """Calculate OAS duration (sensitivity to parallel curve shifts)"""+ shift_size = Decimal('0.0001') # 1 bp++ # Calculate OAS for shifted curves+ up_curve = spot_curve.shift_curve(shift_size, "parallel")+ down_curve = spot_curve.shift_curve(-shift_size, "parallel")++ oas_up = OptionAdjustedSpread.calculate_oas(bond, market_price, up_curve, volatility, steps)+ oas_down = OptionAdjustedSpread.calculate_oas(bond, market_price, down_curve, volatility, steps)++ # Duration = -(dOAS/dy) where y is yield+ return -(oas_up - oas_down) / (Decimal('2') * shift_size)+++class ConvertibleBondValuation:+ """Valuation methods for convertible bonds"""++ @staticmethod+ def convertible_bond_value(convertible: ConvertibleBond, spot_curve: SpotCurve,+ stock_price: Decimal, stock_volatility: Decimal,+ risk_free_rate: Decimal) -> Dict[str, Decimal]:+ """Comprehensive convertible bond valuation"""+ ValidationUtils.validate_positive(stock_price, "Stock price")+ ValidationUtils.validate_positive(stock_volatility, "Stock volatility")+ ValidationUtils.validate_yield(risk_free_rate, "Risk-free rate")++ # 1. Straight bond value+ straight_value = BondValuation.present_value_with_curve(convertible, spot_curve)++ # 2. Conversion value+ conversion_value = convertible.conversion_ratio * stock_price++ # 3. Option value using Black-Scholes approximation+ time_to_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), convertible.maturity_date, convertible.day_count_convention+ )++ # Treat conversion as call option on stock+ conversion_option_value = black_scholes_call_price(+ S=stock_price,+ K=convertible.conversion_price,+ T=time_to_maturity,+ r=risk_free_rate,+ sigma=stock_volatility+ ) * convertible.conversion_ratio++ # 4. Total convertible value (simplified)+ total_value = max(straight_value, conversion_value) + conversion_option_value * Decimal('0.1')++ return {+ 'total_value': total_value,+ 'straight_value': straight_value,+ 'conversion_value': conversion_value,+ 'option_value': conversion_option_value,+ 'conversion_premium': max(Decimal('0'), total_value - conversion_value),+ 'investment_premium': max(Decimal('0'), total_value - straight_value)+ }+++class MatrixPricing:+ """Matrix pricing for illiquid bonds"""++ @staticmethod+ def matrix_price(target_bond: Bond, comparable_bonds: List[Tuple[Bond, Decimal]],+ weights: Optional[List[Decimal]] = None) -> Decimal:+ """Calculate matrix price using comparable bonds"""+ if not comparable_bonds:+ raise ValueError("Need at least one comparable bond")++ if weights is None:+ # Equal weights+ weights = [Decimal('1') / Decimal(str(len(comparable_bonds)))] * len(comparable_bonds)++ if len(weights) != len(comparable_bonds):+ raise ValueError("Number of weights must match number of comparables")++ # Calculate weighted average yield spread+ target_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), target_bond.maturity_date, target_bond.day_count_convention+ )++ weighted_spread = Decimal('0')++ for i, (comp_bond, comp_price) in enumerate(comparable_bonds):+ # Calculate comparable's YTM+ comp_ytm = BondValuation.yield_to_maturity(comp_bond, comp_price)++ # Adjust for maturity difference (simplified)+ maturity_adj = MatrixPricing._maturity_adjustment(target_bond, comp_bond)++ # Adjust for credit difference+ credit_adj = MatrixPricing._credit_adjustment(target_bond, comp_bond)++ adjusted_ytm = comp_ytm + maturity_adj + credit_adj+ weighted_spread += weights[i] * adjusted_ytm++ # Calculate target bond price using weighted spread+ target_price = BondValuation.present_value(target_bond, weighted_spread)++ return target_price++ @staticmethod+ def _maturity_adjustment(target: Bond, comparable: Bond) -> Decimal:+ """Calculate maturity adjustment"""+ target_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), target.maturity_date, target.day_count_convention+ )+ comp_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), comparable.maturity_date, comparable.day_count_convention+ )++ # Simple linear adjustment: 5 bps per year difference+ maturity_diff = target_maturity - comp_maturity+ return maturity_diff * Decimal('0.0005') # 5 bps per year++ @staticmethod+ def _credit_adjustment(target: Bond, comparable: Bond) -> Decimal:+ """Calculate credit quality adjustment"""+ if target.issuer_rating is None or comparable.issuer_rating is None:+ return Decimal('0')++ from config import RATING_SCORES++ target_score = RATING_SCORES.get(target.issuer_rating, 10)+ comp_score = RATING_SCORES.get(comparable.issuer_rating, 10)++ # 25 bps per notch difference+ rating_diff = target_score - comp_score+ return Decimal(str(rating_diff)) * Decimal('0.0025')+++# Utility functions for common valuation scenarios+def value_bond_portfolio(bonds: List[Tuple[Bond, Decimal]], spot_curve: SpotCurve) -> Dict[str, Decimal]:+ """Value a portfolio of bonds"""+ total_value = Decimal('0')+ total_face_value = Decimal('0')++ individual_values = []++ for bond, quantity in bonds:+ bond_value = BondValuation.present_value_with_curve(bond, spot_curve)+ position_value = bond_value * quantity++ total_value += position_value+ total_face_value += bond.face_value * quantity++ individual_values.append({+ 'bond': bond,+ 'quantity': quantity,+ 'unit_value': bond_value,+ 'position_value': position_value+ })++ return {+ 'total_market_value': total_value,+ 'total_face_value': total_face_value,+ 'portfolio_yield': (total_face_value - total_value) / total_value if total_value > 0 else Decimal('0'),+ 'individual_positions': individual_values+ }+++def stress_test_bond(bond: Bond, base_curve: SpotCurve,+ stress_scenarios: List[Tuple[str, Decimal]]) -> Dict[str, Decimal]:+ """Stress test bond value under different scenarios"""+ base_value = BondValuation.present_value_with_curve(bond, base_curve)++ results = {'base_case': base_value}++ for scenario_name, shift_amount in stress_scenarios:+ stressed_curve = base_curve.shift_curve(shift_amount, "parallel")+ stressed_value = BondValuation.present_value_with_curve(bond, stressed_curve)++ results[scenario_name] = {+ 'value': stressed_value,+ 'change': stressed_value - base_value,+ 'percentage_change': (stressed_value - base_value) / base_value * Decimal('100')+ }++ return results\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/yield_curves.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/yield_curves.pynew file mode 100644index 000000000..5770c83a1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/fixedIncome/yield_curves.py@@ -0,0 +1,563 @@++Fixed Income Yield Curves Module+=================================++Yield curve construction and analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - Bond prospectuses and issue documentation+ - Market price data and yield curve information+ - Credit ratings and default recovery rates+ - Interest rate benchmarks and swap curves+ - Macroeconomic data affecting fixed income markets++OUTPUT:+ - Bond valuation models and price calculations+ - Yield curve analysis and forward rate calculations+ - Credit risk assessment and spread analysis+ - Duration and convexity risk metrics+ - Portfolio optimization and immunization strategies++PARAMETERS:+ - yield_curve_method: Yield curve modeling method (default: 'nelson_siegel')+ - credit_spread: Credit spread assumption (default: 0.02)+ - recovery_rate: Default recovery rate (default: 0.40)+ - convexity_adjustment: Convexity adjustment factor (default: 1.0)+ - benchmark_curve: Benchmark yield curve (default: 'treasury')+++from typing import List, Dict, Optional, Tuple+from decimal import Decimal+from datetime import date+from models import YieldCurve, Bond, MarketData+from utils import MathUtils, DateUtils, ValidationUtils, cache_calculation+from config import Currency, CompoundingFrequency, ERROR_TOLERANCE+++class SpotCurve:+ """Zero-coupon (spot) yield curve implementation"""++ def __init__(self, curve: YieldCurve):+ ValidationUtils.validate_date_order(date.today(), curve.curve_date, "Today", "Curve date")+ self.curve = curve+ self._validate_curve()++ def _validate_curve(self):+ """Validate curve data"""+ if len(self.curve.maturities) != len(self.curve.rates):+ raise ValueError("Maturities and rates must have same length")++ # Check ascending order of maturities+ for i in range(1, len(self.curve.maturities)):+ if self.curve.maturities[i] <= self.curve.maturities[i - 1]:+ raise ValueError("Maturities must be in ascending order")++ # Validate all rates+ for rate in self.curve.rates:+ ValidationUtils.validate_yield(rate, "Spot rate")++ @cache_calculation+ def get_rate(self, maturity: Decimal) -> Decimal:+ """Get spot rate for given maturity using interpolation"""+ ValidationUtils.validate_positive(maturity, "Maturity")++ # Exact match+ if maturity in self.curve.maturities:+ index = self.curve.maturities.index(maturity)+ return self.curve.rates[index]++ # Extrapolation for very short or long maturities+ if maturity < self.curve.maturities[0]:+ return self.curve.rates[0] # Flat extrapolation++ if maturity > self.curve.maturities[-1]:+ return self.curve.rates[-1] # Flat extrapolation++ # Linear interpolation+ for i in range(len(self.curve.maturities) - 1):+ if self.curve.maturities[i] <= maturity <= self.curve.maturities[i + 1]:+ return MathUtils.linear_interpolation(+ maturity,+ self.curve.maturities[i], self.curve.rates[i],+ self.curve.maturities[i + 1], self.curve.rates[i + 1]+ )++ return self.curve.rates[0] # Fallback++ def get_discount_factor(self, maturity: Decimal) -> Decimal:+ """Calculate discount factor for given maturity"""+ spot_rate = self.get_rate(maturity)+ return Decimal('1') / ((Decimal('1') + spot_rate) ** maturity)++ def forward_rate(self, start_maturity: Decimal, end_maturity: Decimal) -> Decimal:+ """Calculate forward rate between two maturities"""+ ValidationUtils.validate_positive(start_maturity, "Start maturity")+ ValidationUtils.validate_positive(end_maturity, "End maturity")++ if end_maturity <= start_maturity:+ raise ValueError("End maturity must be greater than start maturity")++ r1 = self.get_rate(start_maturity)+ r2 = self.get_rate(end_maturity)++ # Forward rate formula: (1 + r2)^t2 = (1 + r1)^t1 * (1 + f)^(t2-t1)+ numerator = (Decimal('1') + r2) ** end_maturity+ denominator = (Decimal('1') + r1) ** start_maturity+ time_diff = end_maturity - start_maturity++ forward_factor = numerator / denominator+ return forward_factor ** (Decimal('1') / time_diff) - Decimal('1')++ def shift_curve(self, shift_amount: Decimal, shift_type: str = "parallel") -> 'SpotCurve':+ """Apply parallel or non-parallel shifts to the curve"""+ new_rates = []++ if shift_type == "parallel":+ new_rates = [rate + shift_amount for rate in self.curve.rates]+ elif shift_type == "steepening":+ # Steepening: short rates decrease, long rates increase+ for i, rate in enumerate(self.curve.rates):+ maturity = self.curve.maturities[i]+ # Linear scaling based on maturity+ shift = shift_amount * (maturity / self.curve.maturities[-1])+ new_rates.append(rate + shift)+ elif shift_type == "flattening":+ # Flattening: opposite of steepening+ for i, rate in enumerate(self.curve.rates):+ maturity = self.curve.maturities[i]+ shift = -shift_amount * (maturity / self.curve.maturities[-1])+ new_rates.append(rate + shift)+ else:+ raise ValueError("Invalid shift type. Use 'parallel', 'steepening', or 'flattening'")++ # Validate new rates+ for rate in new_rates:+ ValidationUtils.validate_yield(rate, "Shifted rate")++ new_curve = YieldCurve(+ curve_date=self.curve.curve_date,+ maturities=self.curve.maturities.copy(),+ rates=new_rates,+ currency=self.curve.currency,+ curve_type="spot"+ )++ return SpotCurve(new_curve)+++class ParCurve:+ """Par yield curve implementation"""++ def __init__(self, spot_curve: SpotCurve):+ self.spot_curve = spot_curve+ self.curve_date = spot_curve.curve.curve_date+ self.currency = spot_curve.curve.currency++ @cache_calculation+ def get_par_rate(self, maturity: Decimal,+ frequency: CompoundingFrequency = CompoundingFrequency.SEMI_ANNUAL) -> Decimal:+ """Calculate par rate for given maturity"""+ ValidationUtils.validate_positive(maturity, "Maturity")++ if frequency == CompoundingFrequency.CONTINUOUS:+ # For continuous compounding, par rate equals spot rate+ return self.spot_curve.get_rate(maturity)++ # Calculate discount factors for all payment dates+ payments_per_year = frequency.value+ payment_interval = Decimal('1') / Decimal(str(payments_per_year))++ # Generate payment times+ payment_times = []+ current_time = payment_interval+ while current_time <= maturity:+ payment_times.append(current_time)+ current_time += payment_interval++ # Ensure maturity is included+ if not payment_times or payment_times[-1] != maturity:+ payment_times.append(maturity)++ # Calculate sum of discount factors+ discount_sum = Decimal('0')+ for time in payment_times:+ discount_sum += self.spot_curve.get_discount_factor(time)++ # Final discount factor+ final_discount = self.spot_curve.get_discount_factor(maturity)++ # Par rate formula: (1 - final_discount) / discount_sum+ par_rate = (Decimal('1') - final_discount) / discount_sum++ return par_rate++ def build_par_curve(self, maturities: List[Decimal],+ frequency: CompoundingFrequency = CompoundingFrequency.SEMI_ANNUAL) -> YieldCurve:+ """Build complete par curve for given maturities"""+ par_rates = []++ for maturity in maturities:+ par_rate = self.get_par_rate(maturity, frequency)+ par_rates.append(par_rate)++ return YieldCurve(+ curve_date=self.curve_date,+ maturities=maturities,+ rates=par_rates,+ currency=self.currency,+ curve_type="par"+ )+++class ForwardCurve:+ """Forward rate curve implementation"""++ def __init__(self, spot_curve: SpotCurve):+ self.spot_curve = spot_curve+ self.curve_date = spot_curve.curve.curve_date+ self.currency = spot_curve.curve.currency++ @cache_calculation+ def get_forward_rate(self, start_time: Decimal, end_time: Decimal) -> Decimal:+ """Calculate forward rate between two time points"""+ return self.spot_curve.forward_rate(start_time, end_time)++ def build_forward_curve(self, start_maturity: Decimal,+ end_maturities: List[Decimal]) -> YieldCurve:+ """Build forward curve from start maturity to various end maturities"""+ forward_rates = []++ for end_maturity in end_maturities:+ if end_maturity <= start_maturity:+ raise ValueError(f"End maturity {end_maturity} must be greater than start maturity {start_maturity}")++ forward_rate = self.get_forward_rate(start_maturity, end_maturity)+ forward_rates.append(forward_rate)++ return YieldCurve(+ curve_date=self.curve_date,+ maturities=end_maturities,+ rates=forward_rates,+ currency=self.currency,+ curve_type="forward"+ )++ def instantaneous_forward_rate(self, maturity: Decimal, delta: Decimal = Decimal('0.001')) -> Decimal:+ """Calculate instantaneous forward rate at given maturity"""+ if maturity <= delta:+ return self.spot_curve.get_rate(delta)++ # Approximate derivative using finite difference+ r1 = self.spot_curve.get_rate(maturity - delta / 2)+ r2 = self.spot_curve.get_rate(maturity + delta / 2)++ # Instantaneous forward = d/dt[t * r(t)]+ return r2 + maturity * (r2 - r1) / delta+++class SwapCurve:+ """Interest rate swap curve implementation"""++ def __init__(self, market_data: Dict[str, Decimal], currency: Currency = Currency.USD):+ """+ Initialize with market swap rates+ market_data: Dict with tenor -> rate (e.g., {'2Y': 0.025, '5Y': 0.035})+ """+ self.market_data = market_data+ self.currency = currency+ self.curve_date = date.today()+ self._tenors = []+ self._rates = []+ self._maturities = []+ self._parse_market_data()++ def _parse_market_data(self):+ """Parse market data into tenors, maturities, and rates"""+ for tenor, rate in self.market_data.items():+ self._tenors.append(tenor)+ self._rates.append(rate)++ # Convert tenor to maturity in years+ if tenor.endswith('M'):+ months = int(tenor[:-1])+ maturity = Decimal(months) / Decimal('12')+ elif tenor.endswith('Y'):+ years = int(tenor[:-1])+ maturity = Decimal(years)+ else:+ raise ValueError(f"Invalid tenor format: {tenor}")++ self._maturities.append(maturity)++ # Sort by maturity+ sorted_data = sorted(zip(self._maturities, self._rates, self._tenors))+ self._maturities, self._rates, self._tenors = zip(*sorted_data)+ self._maturities = list(self._maturities)+ self._rates = list(self._rates)+ self._tenors = list(self._tenors)++ def get_swap_rate(self, maturity: Decimal) -> Decimal:+ """Get swap rate for given maturity using interpolation"""+ ValidationUtils.validate_positive(maturity, "Maturity")++ # Exact match+ if maturity in self._maturities:+ index = self._maturities.index(maturity)+ return self._rates[index]++ # Interpolation+ if maturity < self._maturities[0]:+ return self._rates[0]++ if maturity > self._maturities[-1]:+ return self._rates[-1]++ for i in range(len(self._maturities) - 1):+ if self._maturities[i] <= maturity <= self._maturities[i + 1]:+ return MathUtils.linear_interpolation(+ maturity,+ self._maturities[i], self._rates[i],+ self._maturities[i + 1], self._rates[i + 1]+ )++ return self._rates[0]++ def swap_spread(self, maturity: Decimal, treasury_curve: SpotCurve) -> Decimal:+ """Calculate swap spread over treasury curve"""+ swap_rate = self.get_swap_rate(maturity)+ treasury_rate = treasury_curve.get_rate(maturity)+ return swap_rate - treasury_rate++ def to_yield_curve(self) -> YieldCurve:+ """Convert to YieldCurve object"""+ return YieldCurve(+ curve_date=self.curve_date,+ maturities=self._maturities,+ rates=self._rates,+ currency=self.currency,+ curve_type="swap"+ )+++class BootstrappingEngine:+ """Bootstrap yield curves from market instruments"""++ @staticmethod+ def bootstrap_from_bonds(bonds: List[Bond], prices: List[Decimal],+ settlement_date: Optional[date] = None) -> SpotCurve:+ """Bootstrap spot curve from bond prices"""+ if len(bonds) != len(prices):+ raise ValueError("Number of bonds must equal number of prices")++ if settlement_date is None:+ settlement_date = date.today()++ # Sort bonds by maturity+ bond_price_pairs = list(zip(bonds, prices))+ bond_price_pairs.sort(key=lambda x: x[0].maturity_date)++ maturities = []+ spot_rates = []++ for bond, price in bond_price_pairs:+ # Calculate time to maturity+ maturity = DateUtils.calculate_day_count_fraction(+ settlement_date, bond.maturity_date, bond.day_count_convention+ )++ if bond.is_zero_coupon:+ # For zero-coupon bonds, directly calculate spot rate+ # price = face_value / (1 + r)^t+ # r = (face_value / price)^(1/t) - 1+ spot_rate = (bond.face_value / price) ** (Decimal('1') / maturity) - Decimal('1')+ else:+ # For coupon bonds, solve iteratively+ spot_rate = BootstrappingEngine._solve_coupon_bond_rate(+ bond, price, maturity, maturities, spot_rates+ )++ maturities.append(maturity)+ spot_rates.append(spot_rate)++ # Create yield curve+ yield_curve = YieldCurve(+ curve_date=settlement_date,+ maturities=maturities,+ rates=spot_rates,+ currency=bonds[0].currency if bonds else Currency.USD,+ curve_type="spot"+ )++ return SpotCurve(yield_curve)++ @staticmethod+ def _solve_coupon_bond_rate(bond: Bond, price: Decimal, maturity: Decimal,+ existing_maturities: List[Decimal], existing_rates: List[Decimal]) -> Decimal:+ """Solve for spot rate of coupon bond using existing curve"""+ from instruments import BondInstrument++ # Create temporary spot curve with existing rates+ if existing_maturities:+ temp_curve = YieldCurve(+ curve_date=date.today(),+ maturities=existing_maturities,+ rates=existing_rates,+ currency=bond.currency,+ curve_type="spot"+ )+ temp_spot_curve = SpotCurve(temp_curve)+ else:+ temp_spot_curve = None++ # Generate cash flows+ bond_instrument = BondInstrument(bond)+ cash_flows = bond_instrument.generate_cash_flows()++ # Define function to solve: PV of cash flows - market price = 0+ def pv_function(rate: Decimal) -> Decimal:+ total_pv = Decimal('0')++ for cf in cash_flows:+ cf_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), cf.date, bond.day_count_convention+ )++ if cf_maturity < maturity:+ # Use existing curve for earlier cash flows+ if temp_spot_curve:+ discount_rate = temp_spot_curve.get_rate(cf_maturity)+ else:+ discount_rate = rate # Use current rate if no existing curve+ else:+ # Use the rate we're solving for+ discount_rate = rate++ pv = cf.amount / ((Decimal('1') + discount_rate) ** cf_maturity)+ total_pv += pv++ return total_pv - price++ # Derivative for Newton-Raphson+ def pv_derivative(rate: Decimal) -> Decimal:+ total_derivative = Decimal('0')++ for cf in cash_flows:+ cf_maturity = DateUtils.calculate_day_count_fraction(+ date.today(), cf.date, bond.day_count_convention+ )++ if cf_maturity >= maturity: # Only consider cash flows at this maturity+ derivative = -cf_maturity * cf.amount / ((Decimal('1') + rate) ** (cf_maturity + Decimal('1')))+ total_derivative += derivative++ return total_derivative++ # Solve using Newton-Raphson+ try:+ initial_guess = Decimal('0.05') # 5% initial guess+ spot_rate = MathUtils.newton_raphson(pv_function, pv_derivative, initial_guess)+ ValidationUtils.validate_yield(spot_rate, "Bootstrapped spot rate")+ return spot_rate+ except:+ # Fallback to bisection method+ return MathUtils.bisection_method(pv_function, Decimal('0.001'), Decimal('0.50'))+++class CurveAnalysis:+ """Yield curve analysis and metrics"""++ @staticmethod+ def curve_slope(curve: SpotCurve, short_maturity: Decimal = Decimal('2'),+ long_maturity: Decimal = Decimal('10')) -> Decimal:+ """Calculate curve slope between two maturities"""+ short_rate = curve.get_rate(short_maturity)+ long_rate = curve.get_rate(long_maturity)+ return long_rate - short_rate++ @staticmethod+ def curve_curvature(curve: SpotCurve, short_maturity: Decimal = Decimal('2'),+ medium_maturity: Decimal = Decimal('5'),+ long_maturity: Decimal = Decimal('10')) -> Decimal:+ """Calculate curve curvature (butterfly)"""+ short_rate = curve.get_rate(short_maturity)+ medium_rate = curve.get_rate(medium_maturity)+ long_rate = curve.get_rate(long_maturity)++ # Curvature = 2 * medium - short - long+ return Decimal('2') * medium_rate - short_rate - long_rate++ @staticmethod+ def level_slope_curvature_decomposition(curve: SpotCurve) -> Tuple[Decimal, Decimal, Decimal]:+ """Decompose curve into level, slope, and curvature factors"""+ # Use 2Y, 5Y, 10Y points for decomposition+ r2 = curve.get_rate(Decimal('2'))+ r5 = curve.get_rate(Decimal('5'))+ r10 = curve.get_rate(Decimal('10'))++ # Level: average of rates+ level = (r2 + r5 + r10) / Decimal('3')++ # Slope: 10Y - 2Y+ slope = r10 - r2++ # Curvature: butterfly+ curvature = Decimal('2') * r5 - r2 - r10++ return level, slope, curvature++ @staticmethod+ def duration_matched_curve_shift(curve: SpotCurve, target_duration: Decimal,+ shift_amount: Decimal) -> SpotCurve:+ """Apply duration-matched curve shift"""+ # Simplified implementation - apply parallel shift scaled by duration+ duration_scaling = target_duration / Decimal('5') # Normalize to 5-year duration+ scaled_shift = shift_amount * duration_scaling++ return curve.shift_curve(scaled_shift, "parallel")+++# Factory functions for common curve constructions+def create_flat_curve(rate: Decimal, maturities: List[Decimal],+ currency: Currency = Currency.USD) -> SpotCurve:+ """Create flat yield curve with constant rate"""+ rates = [rate] * len(maturities)++ yield_curve = YieldCurve(+ curve_date=date.today(),+ maturities=maturities,+ rates=rates,+ currency=currency,+ curve_type="spot"+ )++ return SpotCurve(yield_curve)+++def create_upward_sloping_curve(short_rate: Decimal, long_rate: Decimal,+ maturities: List[Decimal],+ currency: Currency = Currency.USD) -> SpotCurve:+ """Create upward sloping yield curve"""+ if not maturities:+ raise ValueError("Maturities list cannot be empty")++ min_maturity = min(maturities)+ max_maturity = max(maturities)++ rates = []+ for maturity in maturities:+ # Linear interpolation between short and long rates+ rate = MathUtils.linear_interpolation(+ maturity, min_maturity, short_rate, max_maturity, long_rate+ )+ rates.append(rate)++ yield_curve = YieldCurve(+ curve_date=date.today(),+ maturities=maturities,+ rates=rates,+ currency=currency,+ curve_type="spot"+ )++ return SpotCurve(yield_curve)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/.env.example b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/.env.examplenew file mode 100644index 000000000..84f2c7119--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/.env.example@@ -0,0 +1,8 @@+# OpenRouter API Configuration+# Replace with your actual API key from https://openrouter.ai+OPENROUTER_API_KEY=your-openrouter-api-key-here++# Optional: Custom configuration+# OPENROUTER_BASE_URL=https://openrouter.ai/api/v1+# OPENROUTER_MODEL=moonshotai/kimi-k2:free+# OPENROUTER_TIMEOUT=60\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/README.md b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/README.mdnew file mode 100644index 000000000..2e0a61c34--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/README.md@@ -0,0 +1,132 @@+# Enhanced OpenRouter API Client++An improved Python client for the OpenRouter API with robust error handling, retry logic, and security best practices.++## Features++- **Security**: API keys managed through environment variables or secure configuration+- **Error Handling**: Comprehensive error handling with retry logic and rate limiting support+- **Flexibility**: Configurable parameters for timeout, retries, and model selection+- **Type Safety**: Full type hints and dataclass-based configuration+- **Logging**: Detailed logging and response formatting+- **Examples**: Multiple usage examples included++## Installation++Install required dependencies:++```bash+pip install requests+```++## Quick Start++1. **Set up your API key**: Create a `.env` file based on `.env.example`:+ ```+ OPENROUTER_API_KEY=your-api-key-here+ ```++2. **Run the client**:+ ```bash+ python kimik2.py+ ```++## Usage++### Basic Usage++```python+from kimik2 import OpenRouterClient, OpenRouterConfig++# Initialize client (loads API key from environment)+client = OpenRouterClient()++# Send a simple message+messages = [{"role": "user", "content": "Hello, how are you?"}]+response = client.chat_completion(messages)+client.print_chat_response(response)+```++### Advanced Configuration++```python+from kimik2 import OpenRouterClient, OpenRouterConfig++# Custom configuration+config = OpenRouterConfig(+ timeout=60, # 60 second timeout+ max_retries=5, # 5 retry attempts+ retry_delay=1.5 # 1.5 second delay between retries+)++client = OpenRouterClient(config=config)++# Send with custom parameters+response = client.chat_completion(+ messages=[{"role": "user", "content": "Tell me about AI"}],+ model="moonshotai/kimi-k2:free", # Or specify a different model+ max_tokens=100,+ temperature=0.7+)+```++### Direct API Key Usage++```python+# For testing or when environment variables aren't available+client = OpenRouterClient(api_key="your-api-key-here")+```++## Error Handling++The client handles various error scenarios:++- **Network timeouts**: Automatic retry with exponential backoff+- **Rate limiting**: Respects retry-after headers+- **Invalid responses**: Validates API response structure+- **Configuration errors**: Clear error messages for missing inputs++## Configuration++### Environment Variables++- `OPENROUTER_API_KEY`: Your OpenRouter API key (required)++Optional environment variables:+- `OPENROUTER_BASE_URL`: API base URL (default: https://openrouter.ai/api/v1)+- `OPENROUTER_MODEL`: Default model (default: moonshotai/kimi-k2:free)+- `OPENROUTER_TIMEOUT`: Default timeout in seconds++### Configuration Class++```python+@dataclass+class OpenRouterConfig:+ base_url: str = "https://openrouter.ai/api/v1"+ model: str = "moonshotai/kimi-k2:free"+ timeout: int = 30+ max_retries: int = 3+ retry_delay: float = 1.0+```++## API Response Format++The client provides pretty-printed responses showing:+- Timestamp of response+- Model used+- Message content+- Token usage statistics (when available)+- Response validation++## Best Practices++1. **API Key Security**: Always use environment variables for API keys+2. **Error Handling**: Wrap calls in try-except blocks for graceful error handling+3. **Rate Limiting**: Be mindful of API rate limits, the client handles retries automatically+4. **Testing**: Use the built-in examples to verify your setup++## Files++- `kimik2.py`: Main client implementation+- `.env.example`: Example environment configuration+- `README.md`: This documentation\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/kimik2.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/kimik2.pynew file mode 100644index 000000000..b1c3d056e--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/kimik2.py@@ -0,0 +1,225 @@++Machine Learning Kimik2 Module+======================================++Advanced machine learning trading models++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical market data and price time series+ - Technical indicators and market features+ - Alternative data sources (news, sentiment, etc.)+ - Market microstructure data and order flow+ - Economic indicators and macro data++OUTPUT:+ - Machine learning models for price prediction+ - Trading signals and strategy recommendations+ - Risk forecasts and position sizing suggestions+ - Performance metrics and backtest results+ - Feature importance and model interpretability++PARAMETERS:+ - model_type: Machine learning algorithm (default: 'random_forest')+ - training_window: Training data window size (default: 252 days)+ - prediction_horizon: Prediction horizon (default: 1 day)+ - feature_selection: Feature selection method (default: 'recursive')+ - validation_method: Model validation approach (default: 'time_series_split')+++import requests+import json+import os+import time+from typing import Optional, Dict, Any+from dataclasses import dataclass+from datetime import datetime++@dataclass+class OpenRouterConfig:+ """Configuration for OpenRouter API"""+ base_url: str = "https://openrouter.ai/api/v1"+ model: str = "moonshotai/kimi-k2:free"+ timeout: int = 30+ max_retries: int = 3+ retry_delay: float = 1.0++class OpenRouterClient:+ """Enhanced OpenRouter API client with error handling and retries"""++ def __init__(self, api_key: Optional[str] = None, config: Optional[OpenRouterConfig] = None):+ self.config = config or OpenRouterConfig()+ self.api_key = api_key or os.getenv("OPENROUTER_API_KEY")++ if not self.api_key:+ raise ValueError("API key required. Set OPENROUTER_API_KEY environment variable or pass api_key parameter.")++ def chat_completion(self, messages: list, **kwargs) -> Dict[str, Any]:+ """Send a chat completion request with retry logic"""++ url = f"{self.config.base_url}/chat/completions"+ headers = {+ "Authorization": f"Bearer {self.api_key}",+ "Content-Type": "application/json",+ }++ payload = {+ "model": kwargs.get("model", self.config.model),+ "messages": messages,+ }++ # Add any additional parameters+ payload.update(kwargs)++ for attempt in range(self.config.max_retries):+ try:+ response = requests.post(+ url=url,+ headers=headers,+ json=payload,+ timeout=self.config.timeout+ )++ # Check for rate limiting+ if response.status_code == 429:+ wait_time = int(response.headers.get("retry-after", attempt + 1))+ print(f"Rate limited. Waiting {wait_time} seconds...")+ time.sleep(wait_time)+ continue++ # Raise an exception for bad status codes+ response.raise_for_status()++ result = response.json()++ # Validate response structure+ if "choices" not in result:+ raise ValueError(f"Invalid response format: {result}")++ return result++ except requests.exceptions.RequestException as e:+ if attempt < self.config.max_retries - 1:+ print(f"Request failed (attempt {attempt + 1}/{self.config.max_retries}): {e}")+ time.sleep(self.config.retry_delay * (attempt + 1))+ else:+ print(f"Request failed after {self.config.max_retries} attempts: {e}")+ raise+ except json.JSONDecodeError as e:+ print(f"Failed to decode response: {e}")+ print(f"Raw response: {response.text}")+ raise++ raise RuntimeError("Maximum retries exceeded")++ def print_chat_response(self, response: Dict[str, Any]):+ """Pretty print the chat response"""++ print(f"Response received at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")+ print("-" * 50)++ if "choices" in response and len(response["choices"]) > 0:+ choice = response["choices"][0]+ message = choice.get("message", {})++ print(f"Model: {response.get('model', 'Unknown')}")+ print(f"Role: {message.get('role', 'Unknown')}")++ content = message.get('content', 'No content returned')+ print(f"Content: {content}")++ # Show token usage if available+ if "usage" in response:+ usage = response["usage"]+ print(f"Token usage - Prompt: {usage.get('prompt_tokens', 0)}, "+ f"Completion: {usage.get('completion_tokens', 0)}, "+ f"Total: {usage.get('total_tokens', 0)}")+ else:+ print("No valid response received")+ print(f"Full response: {json.dumps(response, indent=2)}")++ print("-" * 50)++def main():+ """Main function demonstrating the improved client"""++ """+ Example usage demonstrating various API features+ """+ try:+ # Get API key from environment variable+ api_key = os.getenv("OPENROUTER_API_KEY")++ if not api_key:+ print("Error: OPENROUTER_API_KEY environment variable not set.")+ print("Please set your API key using: export OPENROUTER_API_KEY='your-key-here'")+ print("Or create a .env file with: OPENROUTER_API_KEY=your-key-here")+ print("\nFor testing, you can also initialize the client directly:")+ print("client = OpenRouterClient(api_key='your-key-here')")+ return++ # Initialize client with custom configuration+ config = OpenRouterConfig(+ timeout=60, # Increase timeout for complex queries+ max_retries=5, # More retries for reliability+ )++ client = OpenRouterClient(config=config)++ # Various example usages+ print("=== Example 1: Simple Question ===")+ messages1 = [+ {+ "role": "user",+ "content": "What is the meaning of life?"+ }+ ]++ response1 = client.chat_completion(messages1)+ client.print_chat_response(response1)++ print("\n=== Example 2: Multi-turn Conversation ===")+ messages2 = [+ {+ "role": "user",+ "content": "Explain quantum computing in simple terms"+ },+ {+ "role": "assistant",+ "content": "Quantum computing is a type of computing that uses quantum physics principles to solve complex problems that classical computers struggle with. Would you like to know more about specific aspects?"+ },+ {+ "role": "user",+ "content": "Yes, tell me about quantum bits (qubits) and how they differ from regular bits."+ }+ ]++ response2 = client.chat_completion(messages2)+ client.print_chat_response(response2)++ print("\n=== Example 3: Custom Parameters ===")+ # Using different model and parameters+ messages3 = [+ {+ "role": "user",+ "content": "Generate a haiku about artificial intelligence"+ }+ ]++ response3 = client.chat_completion(messages3,+ model="moonshotai/kimi-k2:free",+ max_tokens=50,+ temperature=0.8)+ client.print_chat_response(response3)++ except ValueError as e:+ print(f"Configuration error: {e}")+ except requests.exceptions.RequestException as e:+ print(f"Network error: {e}")+ except Exception as e:+ print(f"Unexpected error: {e}")+ traceback.print_exc()++if __name__ == "__main__":+ import traceback+ main()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/outline.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/outline.pynew file mode 100644index 000000000..025d658db--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/outline.py@@ -0,0 +1,1420 @@++Machine Learning Outline Module+======================================++ML trading framework and architecture++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical market data and price time series+ - Technical indicators and market features+ - Alternative data sources (news, sentiment, etc.)+ - Market microstructure data and order flow+ - Economic indicators and macro data++OUTPUT:+ - Machine learning models for price prediction+ - Trading signals and strategy recommendations+ - Risk forecasts and position sizing suggestions+ - Performance metrics and backtest results+ - Feature importance and model interpretability++PARAMETERS:+ - model_type: Machine learning algorithm (default: 'random_forest')+ - training_window: Training data window size (default: 252 days)+ - prediction_horizon: Prediction horizon (default: 1 day)+ - feature_selection: Feature selection method (default: 'recursive')+ - validation_method: Model validation approach (default: 'time_series_split')+++import numpy as np+import pandas as pd+import warnings+warnings.filterwarnings('ignore')++# Core libraries+from typing import Dict, List, Tuple, Optional, Union, Any+from dataclasses import dataclass+from abc import ABC, abstractmethod+from datetime import datetime, timedelta+import logging+import pickle+import json++# Data and preprocessing+from sklearn.preprocessing import StandardScaler, MinMaxScaler, RobustScaler+from sklearn.model_selection import TimeSeriesSplit, cross_val_score+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score+from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score++# Traditional ML models+from sklearn.linear_model import LinearRegression, Ridge, Lasso, LogisticRegression+from sklearn.ensemble import RandomForestRegressor, RandomForestClassifier+from sklearn.ensemble import GradientBoostingRegressor, GradientBoostingClassifier+from sklearn.tree import DecisionTreeRegressor, DecisionTreeClassifier+from sklearn.naive_bayes import MultinomialNB, GaussianNB+from sklearn.svm import SVR, SVC++# Dimensionality reduction and clustering+from sklearn.decomposition import PCA, FastICA, FactorAnalysis+from sklearn.manifold import TSNE+from sklearn.cluster import KMeans, AgglomerativeClustering, DBSCAN++# Time series analysis+from statsmodels.tsa.arima.model import ARIMA+from statsmodels.tsa.vector_ar.var_model import VAR+from statsmodels.tsa.stattools import coint, adfuller+from statsmodels.stats.stattools import jarque_bera++# Deep learning (conceptual - would need actual implementations)+# import tensorflow as tf+# import torch+# import torch.nn as nn++# Visualization+import matplotlib.pyplot as plt+import seaborn as sns+import plotly.graph_objects as go+import plotly.express as px+from plotly.subplots import make_subplots++# ============================================================================+# CONFIGURATION AND LOGGING+# ============================================================================++@dataclass+class ML4TConfig:+ """Configuration settings for ML4T module"""+ data_path: str = "data/"+ models_path: str = "models/"+ results_path: str = "results/"+ log_level: str = "INFO"+ random_state: int = 42+ test_size: float = 0.2+ validation_size: float = 0.2+ n_jobs: int = -1++ # Trading specific+ trading_costs: float = 0.001 # 0.1% per trade+ slippage: float = 0.0005 # 0.05% slippage+ initial_capital: float = 100000.0++ # Risk management+ max_position_size: float = 0.1 # 10% max position+ stop_loss: float = -0.05 # 5% stop loss+ take_profit: float = 0.15 # 15% take profit++class ML4TLogger:+ """Centralized logging for ML4T module"""+ def __init__(self, name: str = "ML4T", level: str = "INFO"):+ self.logger = logging.getLogger(name)+ self.logger.setLevel(getattr(logging, level))++ if not self.logger.handlers:+ handler = logging.StreamHandler()+ formatter = logging.Formatter(+ '%(asctime)s - %(name)s - %(levelname)s - %(message)s'+ )+ handler.setFormatter(formatter)+ self.logger.addHandler(handler)++ def info(self, msg): self.logger.info(msg)+ def warning(self, msg): self.logger.warning(msg)+ def error(self, msg): self.logger.error(msg)+ def debug(self, msg): self.logger.debug(msg)++# ============================================================================+# DATA MANAGEMENT AND ACQUISITION+# ============================================================================++class DataManager:+ """Handles data acquisition, storage, and preprocessing"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger("DataManager")+ self.data_cache = {}++ def load_market_data(self, symbols: List[str], start_date: str, end_date: str) -> pd.DataFrame:+ """Load market data for given symbols and date range"""+ # Placeholder implementation - would integrate with actual data providers+ self.logger.info(f"Loading market data for {len(symbols)} symbols from {start_date} to {end_date}")++ # Generate synthetic data for demonstration+ dates = pd.date_range(start=start_date, end=end_date, freq='D')+ np.random.seed(self.config.random_state)++ data = {}+ for symbol in symbols:+ n_days = len(dates)+ # Generate realistic price data with random walk+ returns = np.random.normal(0.0005, 0.02, n_days) # Daily returns+ prices = 100 * np.exp(np.cumsum(returns)) # Price series++ volumes = np.random.lognormal(10, 1, n_days)++ symbol_data = pd.DataFrame({+ 'open': prices * (1 + np.random.normal(0, 0.001, n_days)),+ 'high': prices * (1 + np.abs(np.random.normal(0, 0.005, n_days))),+ 'low': prices * (1 - np.abs(np.random.normal(0, 0.005, n_days))),+ 'close': prices,+ 'volume': volumes,+ 'symbol': symbol+ }, index=dates)++ data[symbol] = symbol_data++ combined_data = pd.concat(data.values(), ignore_index=False)+ combined_data = combined_data.reset_index().rename(columns={'index': 'date'})++ self.data_cache['market_data'] = combined_data+ return combined_data++ def load_fundamental_data(self, symbols: List[str]) -> pd.DataFrame:+ """Load fundamental data from SEC filings"""+ self.logger.info(f"Loading fundamental data for {len(symbols)} symbols")++ # Generate synthetic fundamental data+ np.random.seed(self.config.random_state)++ fundamental_data = []+ for symbol in symbols:+ data = {+ 'symbol': symbol,+ 'market_cap': np.random.lognormal(15, 2), # Market cap+ 'pe_ratio': np.random.lognormal(3, 0.5), # P/E ratio+ 'pb_ratio': np.random.lognormal(1, 0.3), # P/B ratio+ 'debt_to_equity': np.random.exponential(0.5), # D/E ratio+ 'roe': np.random.normal(0.12, 0.05), # Return on Equity+ 'roa': np.random.normal(0.06, 0.03), # Return on Assets+ 'current_ratio': np.random.lognormal(1, 0.2), # Current ratio+ 'revenue_growth': np.random.normal(0.05, 0.15), # Revenue growth+ 'earnings_growth': np.random.normal(0.08, 0.20), # Earnings growth+ }+ fundamental_data.append(data)++ df = pd.DataFrame(fundamental_data)+ self.data_cache['fundamental_data'] = df+ return df++ def load_alternative_data(self, data_type: str) -> pd.DataFrame:+ """Load alternative data (sentiment, satellite, etc.)"""+ self.logger.info(f"Loading alternative data: {data_type}")++ if data_type == "sentiment":+ return self._generate_sentiment_data()+ elif data_type == "satellite":+ return self._generate_satellite_data()+ elif data_type == "social":+ return self._generate_social_data()+ else:+ raise ValueError(f"Unknown alternative data type: {data_type}")++ def _generate_sentiment_data(self) -> pd.DataFrame:+ """Generate synthetic sentiment data"""+ dates = pd.date_range(start='2020-01-01', end='2023-12-31', freq='D')+ np.random.seed(self.config.random_state)++ sentiment_data = pd.DataFrame({+ 'date': dates,+ 'news_sentiment': np.random.normal(0, 1, len(dates)),+ 'social_sentiment': np.random.normal(0, 1.2, len(dates)),+ 'analyst_sentiment': np.random.normal(0, 0.8, len(dates)),+ 'earnings_sentiment': np.random.normal(0, 1.5, len(dates)),+ })++ return sentiment_data++ def _generate_satellite_data(self) -> pd.DataFrame:+ """Generate synthetic satellite data"""+ # Placeholder for satellite imagery analysis results+ return pd.DataFrame({+ 'region': ['US_MIDWEST', 'BRAZIL_CERRADO', 'ARGENTINA_PAMPAS'],+ 'crop_health_index': [0.85, 0.78, 0.82],+ 'estimated_yield': [105.2, 89.7, 94.3],+ 'weather_risk': [0.15, 0.25, 0.18]+ })++ def _generate_social_data(self) -> pd.DataFrame:+ """Generate synthetic social media data"""+ dates = pd.date_range(start='2020-01-01', end='2023-12-31', freq='D')+ np.random.seed(self.config.random_state)++ return pd.DataFrame({+ 'date': dates,+ 'twitter_mentions': np.random.poisson(100, len(dates)),+ 'reddit_sentiment': np.random.normal(0, 1, len(dates)),+ 'google_trends': np.random.uniform(0, 100, len(dates)),+ 'news_volume': np.random.poisson(50, len(dates))+ })++# ============================================================================+# FEATURE ENGINEERING AND ALPHA FACTORS+# ============================================================================++class AlphaFactorEngine:+ """Comprehensive alpha factor generation and evaluation"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger("AlphaEngine")+ self.factor_library = {}++ def calculate_technical_factors(self, data: pd.DataFrame, symbol: str) -> pd.DataFrame:+ """Calculate technical indicators and factors"""+ df = data[data['symbol'] == symbol].copy()+ df = df.sort_values('date')++ # Price-based factors+ df['returns'] = df['close'].pct_change()+ df['log_returns'] = np.log(df['close']).diff()++ # Moving averages+ for window in [5, 10, 20, 50, 200]:+ df[f'sma_{window}'] = df['close'].rolling(window).mean()+ df[f'ema_{window}'] = df['close'].ewm(span=window).mean()++ # Price momentum+ for window in [5, 10, 20]:+ df[f'momentum_{window}'] = df['close'] / df['close'].shift(window) - 1++ # Volatility measures+ for window in [5, 10, 20]:+ df[f'volatility_{window}'] = df['returns'].rolling(window).std()++ # RSI+ df['rsi_14'] = self._calculate_rsi(df['close'], 14)++ # Bollinger Bands+ df['bb_upper'], df['bb_lower'] = self._calculate_bollinger_bands(df['close'], 20)+ df['bb_position'] = (df['close'] - df['bb_lower']) / (df['bb_upper'] - df['bb_lower'])++ # MACD+ df['macd'], df['macd_signal'] = self._calculate_macd(df['close'])+ df['macd_histogram'] = df['macd'] - df['macd_signal']++ # Volume factors+ df['volume_sma_20'] = df['volume'].rolling(20).mean()+ df['volume_ratio'] = df['volume'] / df['volume_sma_20']++ # Price-Volume factors+ df['vwap'] = (df['close'] * df['volume']).rolling(20).sum() / df['volume'].rolling(20).sum()+ df['price_volume_trend'] = ((df['close'] - df['close'].shift(1)) / df['close'].shift(1) * df['volume']).rolling(20).sum()++ return df++ def calculate_fundamental_factors(self, market_data: pd.DataFrame, fundamental_data: pd.DataFrame) -> pd.DataFrame:+ """Calculate fundamental analysis factors"""+ merged_data = market_data.merge(fundamental_data, on='symbol', how='left')++ # Valuation ratios+ merged_data['price_to_book'] = merged_data['pb_ratio']+ merged_data['price_to_earnings'] = merged_data['pe_ratio']++ # Quality factors+ merged_data['return_on_equity'] = merged_data['roe']+ merged_data['return_on_assets'] = merged_data['roa']+ merged_data['debt_equity_ratio'] = merged_data['debt_to_equity']++ # Growth factors+ merged_data['revenue_growth_rate'] = merged_data['revenue_growth']+ merged_data['earnings_growth_rate'] = merged_data['earnings_growth']++ return merged_data++ def calculate_alternative_factors(self, data: pd.DataFrame, alt_data: Dict[str, pd.DataFrame]) -> pd.DataFrame:+ """Integrate alternative data factors"""+ result = data.copy()++ # Sentiment factors+ if 'sentiment' in alt_data:+ sentiment = alt_data['sentiment']+ result = result.merge(sentiment, on='date', how='left')++ # Create sentiment momentum+ result['sentiment_momentum'] = result['news_sentiment'].rolling(5).mean()+ result['sentiment_volatility'] = result['news_sentiment'].rolling(10).std()++ # Social media factors+ if 'social' in alt_data:+ social = alt_data['social']+ result = result.merge(social, on='date', how='left')++ # Social activity factors+ result['social_activity'] = result['twitter_mentions'] + result['news_volume']+ result['social_sentiment_trend'] = result['reddit_sentiment'].rolling(7).mean()++ return result++ def _calculate_rsi(self, prices: pd.Series, window: int = 14) -> pd.Series:+ """Calculate Relative Strength Index"""+ delta = prices.diff()+ gain = delta.where(delta > 0, 0).rolling(window=window).mean()+ loss = (-delta.where(delta < 0, 0)).rolling(window=window).mean()+ rs = gain / loss+ rsi = 100 - (100 / (1 + rs))+ return rsi++ def _calculate_bollinger_bands(self, prices: pd.Series, window: int = 20, num_std: float = 2) -> Tuple[pd.Series, pd.Series]:+ """Calculate Bollinger Bands"""+ sma = prices.rolling(window).mean()+ std = prices.rolling(window).std()+ upper = sma + (std * num_std)+ lower = sma - (std * num_std)+ return upper, lower++ def _calculate_macd(self, prices: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> Tuple[pd.Series, pd.Series]:+ """Calculate MACD"""+ ema_fast = prices.ewm(span=fast).mean()+ ema_slow = prices.ewm(span=slow).mean()+ macd = ema_fast - ema_slow+ macd_signal = macd.ewm(span=signal).mean()+ return macd, macd_signal++ def evaluate_factor_performance(self, data: pd.DataFrame, factor_name: str, target: str = 'returns') -> Dict:+ """Evaluate factor performance using various metrics"""+ # Information Coefficient (Spearman correlation)+ ic = data[factor_name].corr(data[target], method='spearman')++ # Factor returns by quintiles+ data['factor_quintile'] = pd.qcut(data[factor_name].rank(), 5, labels=['Q1', 'Q2', 'Q3', 'Q4', 'Q5'])+ quintile_returns = data.groupby('factor_quintile')[target].mean()++ # Long-short return (Q5 - Q1)+ long_short_return = quintile_returns['Q5'] - quintile_returns['Q1']++ return {+ 'information_coefficient': ic,+ 'quintile_returns': quintile_returns.to_dict(),+ 'long_short_return': long_short_return,+ 'factor_stats': {+ 'mean': data[factor_name].mean(),+ 'std': data[factor_name].std(),+ 'skewness': data[factor_name].skew(),+ 'kurtosis': data[factor_name].kurtosis()+ }+ }++# ============================================================================+# MACHINE LEARNING MODELS+# ============================================================================++class BaseMLModel(ABC):+ """Abstract base class for all ML models"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger(self.__class__.__name__)+ self.model = None+ self.is_fitted = False+ self.feature_importance_ = None++ @abstractmethod+ def fit(self, X: pd.DataFrame, y: pd.Series) -> 'BaseMLModel':+ pass++ @abstractmethod+ def predict(self, X: pd.DataFrame) -> np.ndarray:+ pass++ def evaluate(self, X_test: pd.DataFrame, y_test: pd.Series) -> Dict:+ """Evaluate model performance"""+ predictions = self.predict(X_test)++ if len(np.unique(y_test)) == 2: # Binary classification+ metrics = {+ 'accuracy': accuracy_score(y_test, predictions),+ 'precision': precision_score(y_test, predictions),+ 'recall': recall_score(y_test, predictions),+ 'f1_score': f1_score(y_test, predictions)+ }+ else: # Regression+ metrics = {+ 'mse': mean_squared_error(y_test, predictions),+ 'mae': mean_absolute_error(y_test, predictions),+ 'r2': r2_score(y_test, predictions),+ 'rmse': np.sqrt(mean_squared_error(y_test, predictions))+ }++ return metrics++class LinearModel(BaseMLModel):+ """Linear regression and classification models"""++ def __init__(self, config: ML4TConfig, model_type: str = 'ridge', alpha: float = 1.0):+ super().__init__(config)+ self.model_type = model_type+ self.alpha = alpha++ if model_type == 'linear':+ self.model = LinearRegression()+ elif model_type == 'ridge':+ self.model = Ridge(alpha=alpha, random_state=config.random_state)+ elif model_type == 'lasso':+ self.model = Lasso(alpha=alpha, random_state=config.random_state)+ elif model_type == 'logistic':+ self.model = LogisticRegression(random_state=config.random_state)+ else:+ raise ValueError(f"Unknown model type: {model_type}")++ def fit(self, X: pd.DataFrame, y: pd.Series) -> 'LinearModel':+ self.model.fit(X, y)+ self.is_fitted = True++ # Feature importance for linear models (coefficients)+ if hasattr(self.model, 'coef_'):+ self.feature_importance_ = pd.Series(+ np.abs(self.model.coef_),+ index=X.columns+ ).sort_values(ascending=False)++ return self++ def predict(self, X: pd.DataFrame) -> np.ndarray:+ if not self.is_fitted:+ raise ValueError("Model must be fitted before making predictions")+ return self.model.predict(X)++class TreeBasedModel(BaseMLModel):+ """Random Forest and Gradient Boosting models"""++ def __init__(self, config: ML4TConfig, model_type: str = 'random_forest', **kwargs):+ super().__init__(config)+ self.model_type = model_type++ # Base parameters for all models+ base_params = {+ 'n_estimators': 100,+ 'random_state': config.random_state+ }++ # Add n_jobs only for models that support it (Random Forest)+ if model_type in ['random_forest', 'random_forest_classifier']:+ base_params['n_jobs'] = config.n_jobs++ # Update with user-provided parameters+ base_params.update(kwargs)++ if model_type == 'random_forest':+ self.model = RandomForestRegressor(**base_params)+ elif model_type == 'random_forest_classifier':+ self.model = RandomForestClassifier(**base_params)+ elif model_type == 'gradient_boosting':+ self.model = GradientBoostingRegressor(**base_params)+ elif model_type == 'gradient_boosting_classifier':+ self.model = GradientBoostingClassifier(**base_params)+ else:+ raise ValueError(f"Unknown model type: {model_type}")++ def fit(self, X: pd.DataFrame, y: pd.Series) -> 'TreeBasedModel':+ self.model.fit(X, y)+ self.is_fitted = True++ # Feature importance+ self.feature_importance_ = pd.Series(+ self.model.feature_importances_,+ index=X.columns+ ).sort_values(ascending=False)++ return self++ def predict(self, X: pd.DataFrame) -> np.ndarray:+ if not self.is_fitted:+ raise ValueError("Model must be fitted before making predictions")+ return self.model.predict(X)++class TimeSeriesModel(BaseMLModel):+ """Time series models (ARIMA, VAR, etc.)"""++ def __init__(self, config: ML4TConfig, model_type: str = 'arima', **kwargs):+ super().__init__(config)+ self.model_type = model_type+ self.model_params = kwargs++ def fit(self, X: pd.DataFrame, y: pd.Series) -> 'TimeSeriesModel':+ if self.model_type == 'arima':+ order = self.model_params.get('order', (1, 1, 1))+ self.model = ARIMA(y, order=order)+ self.model = self.model.fit()++ self.is_fitted = True+ return self++ def predict(self, X: pd.DataFrame) -> np.ndarray:+ if not self.is_fitted:+ raise ValueError("Model must be fitted before making predictions")++ if self.model_type == 'arima':+ forecast = self.model.forecast(steps=len(X))+ return forecast.values++ return np.array([])++# ============================================================================+# PORTFOLIO OPTIMIZATION AND RISK MANAGEMENT+# ============================================================================++class PortfolioOptimizer:+ """Modern Portfolio Theory and risk-based optimization"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger("PortfolioOptimizer")++ def mean_variance_optimization(self, returns: pd.DataFrame, risk_aversion: float = 1.0) -> pd.Series:+ """Classic Markowitz mean-variance optimization"""+ mu = returns.mean()+ cov_matrix = returns.cov()++ n = len(mu)+ # Objective: maximize mu'w - 0.5 * risk_aversion * w'Σw+ # Subject to: sum(w) = 1++ # Simplified solution (equal risk contribution)+ inv_cov = np.linalg.pinv(cov_matrix)+ ones = np.ones((n, 1))++ # Calculate optimal weights+ weights = inv_cov @ mu+ weights = weights / np.sum(weights)++ return pd.Series(weights, index=returns.columns)++ def risk_parity_optimization(self, returns: pd.DataFrame) -> pd.Series:+ """Risk parity portfolio optimization"""+ cov_matrix = returns.cov()++ # Start with equal weights+ n = len(returns.columns)+ weights = np.ones(n) / n++ # Iterative risk budgeting (simplified)+ for _ in range(50): # Max iterations+ portfolio_vol = np.sqrt(weights.T @ cov_matrix @ weights)+ marginal_contrib = cov_matrix @ weights / portfolio_vol+ risk_contrib = weights * marginal_contrib++ # Adjust weights to equalize risk contributions+ target_risk = np.mean(risk_contrib)+ adjustment = target_risk / risk_contrib+ weights = weights * adjustment+ weights = weights / np.sum(weights) # Normalize++ return pd.Series(weights, index=returns.columns)++ def black_litterman_optimization(self, returns: pd.DataFrame, views: Dict = None) -> pd.Series:+ """Black-Litterman model with investor views"""+ # Simplified implementation+ mu = returns.mean()+ cov_matrix = returns.cov()++ if views is None:+ # No views, revert to market capitalization weighting+ weights = np.ones(len(returns.columns)) / len(returns.columns)+ else:+ # Incorporate views (simplified)+ weights = self.mean_variance_optimization(returns)++ return pd.Series(weights, index=returns.columns)++ def calculate_portfolio_metrics(self, returns: pd.Series, benchmark_returns: pd.Series = None) -> Dict:+ """Calculate comprehensive portfolio performance metrics"""++ # Basic metrics+ total_return = (1 + returns).prod() - 1+ annualized_return = (1 + returns.mean()) ** 252 - 1+ annualized_volatility = returns.std() * np.sqrt(252)+ sharpe_ratio = annualized_return / annualized_volatility if annualized_volatility > 0 else 0++ # Downside metrics+ downside_returns = returns[returns < 0]+ downside_deviation = downside_returns.std() * np.sqrt(252)+ sortino_ratio = annualized_return / downside_deviation if downside_deviation > 0 else 0++ # Drawdown analysis+ cumulative_returns = (1 + returns).cumprod()+ rolling_max = cumulative_returns.expanding().max()+ drawdown = (cumulative_returns - rolling_max) / rolling_max+ max_drawdown = drawdown.min()++ # VaR and CVaR+ var_95 = returns.quantile(0.05)+ cvar_95 = returns[returns <= var_95].mean()++ metrics = {+ 'total_return': total_return,+ 'annualized_return': annualized_return,+ 'annualized_volatility': annualized_volatility,+ 'sharpe_ratio': sharpe_ratio,+ 'sortino_ratio': sortino_ratio,+ 'max_drawdown': max_drawdown,+ 'var_95': var_95,+ 'cvar_95': cvar_95,+ 'calmar_ratio': annualized_return / abs(max_drawdown) if max_drawdown != 0 else 0+ }++ # Benchmark comparison+ if benchmark_returns is not None:+ benchmark_return = (1 + benchmark_returns.mean()) ** 252 - 1+ alpha = annualized_return - benchmark_return++ # Beta calculation+ covariance = returns.cov(benchmark_returns)+ benchmark_variance = benchmark_returns.var()+ beta = covariance / benchmark_variance if benchmark_variance > 0 else 0++ # Information ratio+ active_returns = returns - benchmark_returns+ tracking_error = active_returns.std() * np.sqrt(252)+ information_ratio = (active_returns.mean() * 252) / tracking_error if tracking_error > 0 else 0++ metrics.update({+ 'alpha': alpha,+ 'beta': beta,+ 'information_ratio': information_ratio,+ 'tracking_error': tracking_error+ })++ return metrics++# ============================================================================+# BACKTESTING ENGINE+# ============================================================================++class BacktestEngine:+ """Comprehensive backtesting framework"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger("BacktestEngine")+ self.results = {}++ def run_backtest(self, strategy_signals: pd.DataFrame, price_data: pd.DataFrame,+ initial_capital: float = None) -> Dict:+ """Execute complete backtest simulation"""++ if initial_capital is None:+ initial_capital = self.config.initial_capital++ # Initialize portfolio+ portfolio = {+ 'cash': initial_capital,+ 'positions': {},+ 'portfolio_value': [initial_capital],+ 'dates': [],+ 'trades': []+ }++ # Sort by date+ signals = strategy_signals.sort_values('date')+ prices = price_data.sort_values('date')++ # Execute backtest day by day+ for date in signals['date'].unique():+ daily_signals = signals[signals['date'] == date]+ daily_prices = prices[prices['date'] == date]++ portfolio = self._process_daily_signals(portfolio, daily_signals, daily_prices, date)++ # Calculate portfolio value+ portfolio_value = self._calculate_portfolio_value(portfolio, daily_prices)+ portfolio['portfolio_value'].append(portfolio_value)+ portfolio['dates'].append(date)++ # Calculate performance metrics+ returns = pd.Series(portfolio['portfolio_value']).pct_change().dropna()+ portfolio_optimizer = PortfolioOptimizer(self.config)+ metrics = portfolio_optimizer.calculate_portfolio_metrics(returns)++ return {+ 'portfolio_values': portfolio['portfolio_value'],+ 'dates': portfolio['dates'],+ 'trades': portfolio['trades'],+ 'positions': portfolio['positions'],+ 'metrics': metrics,+ 'returns': returns+ }++ def _process_daily_signals(self, portfolio: Dict, signals: pd.DataFrame,+ prices: pd.DataFrame, date) -> Dict:+ """Process trading signals for a single day"""++ for _, signal in signals.iterrows():+ symbol = signal['symbol']+ signal_strength = signal.get('signal', 0)++ # Get current price+ price_row = prices[prices['symbol'] == symbol]+ if price_row.empty:+ continue++ current_price = price_row['close'].iloc[0]++ # Calculate position size based on signal strength+ target_position_value = portfolio['cash'] * self.config.max_position_size * signal_strength+ target_shares = int(target_position_value / current_price)++ # Current position+ current_shares = portfolio['positions'].get(symbol, 0)+ shares_to_trade = target_shares - current_shares++ if abs(shares_to_trade) > 0:+ trade_value = shares_to_trade * current_price+ trading_cost = abs(trade_value) * self.config.trading_costs++ # Check if we have enough cash for the trade+ if shares_to_trade > 0: # Buying+ total_cost = trade_value + trading_cost+ if total_cost <= portfolio['cash']:+ portfolio['cash'] -= total_cost+ portfolio['positions'][symbol] = current_shares + shares_to_trade++ # Record trade+ portfolio['trades'].append({+ 'date': date,+ 'symbol': symbol,+ 'shares': shares_to_trade,+ 'price': current_price,+ 'value': trade_value,+ 'cost': trading_cost,+ 'type': 'BUY'+ })++ else: # Selling+ portfolio['cash'] += abs(trade_value) - trading_cost+ portfolio['positions'][symbol] = current_shares + shares_to_trade++ # Record trade+ portfolio['trades'].append({+ 'date': date,+ 'symbol': symbol,+ 'shares': shares_to_trade,+ 'price': current_price,+ 'value': trade_value,+ 'cost': trading_cost,+ 'type': 'SELL'+ })++ return portfolio++ def _calculate_portfolio_value(self, portfolio: Dict, prices: pd.DataFrame) -> float:+ """Calculate total portfolio value"""+ total_value = portfolio['cash']++ for symbol, shares in portfolio['positions'].items():+ if shares != 0:+ price_row = prices[prices['symbol'] == symbol]+ if not price_row.empty:+ current_price = price_row['close'].iloc[0]+ total_value += shares * current_price++ return total_value++ def run_walk_forward_analysis(self, model, data: pd.DataFrame, features: List[str],+ target: str, train_window: int = 252,+ test_window: int = 21) -> Dict:+ """Run walk-forward analysis for model validation"""++ results = []+ data = data.sort_values('date')++ start_idx = train_window+ while start_idx + test_window < len(data):+ # Training data+ train_data = data.iloc[start_idx - train_window:start_idx]+ test_data = data.iloc[start_idx:start_idx + test_window]++ # Prepare features+ X_train = train_data[features].fillna(0)+ y_train = train_data[target].fillna(0)+ X_test = test_data[features].fillna(0)+ y_test = test_data[target].fillna(0)++ # Train model+ model.fit(X_train, y_train)++ # Make predictions+ predictions = model.predict(X_test)++ # Evaluate+ metrics = model.evaluate(X_test, y_test)++ results.append({+ 'train_start': train_data['date'].iloc[0],+ 'train_end': train_data['date'].iloc[-1],+ 'test_start': test_data['date'].iloc[0],+ 'test_end': test_data['date'].iloc[-1],+ 'metrics': metrics,+ 'predictions': predictions,+ 'actual': y_test.values+ })++ start_idx += test_window++ return {+ 'results': results,+ 'summary_metrics': self._summarize_walk_forward_results(results)+ }++ def _summarize_walk_forward_results(self, results: List[Dict]) -> Dict:+ """Summarize walk-forward analysis results"""+ metrics_list = [r['metrics'] for r in results]++ summary = {}+ for metric in metrics_list[0].keys():+ values = [m[metric] for m in metrics_list]+ summary[f'{metric}_mean'] = np.mean(values)+ summary[f'{metric}_std'] = np.std(values)+ summary[f'{metric}_min'] = np.min(values)+ summary[f'{metric}_max'] = np.max(values)++ return summary++# ============================================================================+# STRATEGY DEVELOPMENT FRAMEWORK+# ============================================================================++class TradingStrategy(ABC):+ """Abstract base class for trading strategies"""++ def __init__(self, name: str, config: ML4TConfig):+ self.name = name+ self.config = config+ self.logger = ML4TLogger(f"Strategy_{name}")+ self.model = None+ self.features = []++ @abstractmethod+ def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:+ """Generate trading signals"""+ pass++ def set_model(self, model: BaseMLModel):+ """Set the ML model for the strategy"""+ self.model = model++ def set_features(self, features: List[str]):+ """Set feature list for the strategy"""+ self.features = features++class MeanReversionStrategy(TradingStrategy):+ """Mean reversion strategy implementation"""++ def __init__(self, config: ML4TConfig, lookback_window: int = 20,+ entry_threshold: float = 2.0, exit_threshold: float = 0.5):+ super().__init__("MeanReversion", config)+ self.lookback_window = lookback_window+ self.entry_threshold = entry_threshold+ self.exit_threshold = exit_threshold++ def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:+ """Generate mean reversion signals"""+ signals = []++ for symbol in data['symbol'].unique():+ symbol_data = data[data['symbol'] == symbol].copy()+ symbol_data = symbol_data.sort_values('date')++ # Calculate z-score+ symbol_data['rolling_mean'] = symbol_data['close'].rolling(self.lookback_window).mean()+ symbol_data['rolling_std'] = symbol_data['close'].rolling(self.lookback_window).std()+ symbol_data['z_score'] = (symbol_data['close'] - symbol_data['rolling_mean']) / symbol_data['rolling_std']++ # Generate signals+ symbol_data['signal'] = 0++ # Long signal when price is oversold (negative z-score)+ symbol_data.loc[symbol_data['z_score'] < -self.entry_threshold, 'signal'] = 1++ # Short signal when price is overbought (positive z-score)+ symbol_data.loc[symbol_data['z_score'] > self.entry_threshold, 'signal'] = -1++ # Exit signals+ symbol_data.loc[abs(symbol_data['z_score']) < self.exit_threshold, 'signal'] = 0++ signals.append(symbol_data[['date', 'symbol', 'signal']])++ return pd.concat(signals, ignore_index=True)++class MomentumStrategy(TradingStrategy):+ """Momentum strategy implementation"""++ def __init__(self, config: ML4TConfig, lookback_window: int = 12,+ holding_period: int = 3):+ super().__init__("Momentum", config)+ self.lookback_window = lookback_window+ self.holding_period = holding_period++ def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:+ """Generate momentum signals"""+ signals = []++ for symbol in data['symbol'].unique():+ symbol_data = data[data['symbol'] == symbol].copy()+ symbol_data = symbol_data.sort_values('date')++ # Calculate momentum+ symbol_data['momentum'] = symbol_data['close'].pct_change(self.lookback_window)++ # Rank-based signals+ symbol_data['momentum_rank'] = symbol_data['momentum'].rank(pct=True)++ # Generate signals based on momentum quintiles+ symbol_data['signal'] = 0+ symbol_data.loc[symbol_data['momentum_rank'] > 0.8, 'signal'] = 1 # Top quintile+ symbol_data.loc[symbol_data['momentum_rank'] < 0.2, 'signal'] = -1 # Bottom quintile++ signals.append(symbol_data[['date', 'symbol', 'signal']])++ return pd.concat(signals, ignore_index=True)++class MLStrategy(TradingStrategy):+ """Machine Learning-based strategy"""++ def __init__(self, config: ML4TConfig, model: BaseMLModel,+ features: List[str], target: str = 'future_returns'):+ super().__init__("MLStrategy", config)+ self.model = model+ self.features = features+ self.target = target++ def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:+ """Generate ML-based signals"""++ # Prepare features+ feature_data = data[self.features].fillna(0)++ # Make predictions+ predictions = self.model.predict(feature_data)++ # Convert predictions to signals+ signals_df = data[['date', 'symbol']].copy()+ signals_df['prediction'] = predictions++ # Signal generation logic+ prediction_threshold = np.std(predictions) * 0.5+ signals_df['signal'] = 0+ signals_df.loc[predictions > prediction_threshold, 'signal'] = 1+ signals_df.loc[predictions < -prediction_threshold, 'signal'] = -1++ return signals_df[['date', 'symbol', 'signal']]++# ============================================================================+# VISUALIZATION AND REPORTING+# ============================================================================++class ML4TVisualizer:+ """Comprehensive visualization toolkit for ML4T"""++ def __init__(self, config: ML4TConfig):+ self.config = config+ self.logger = ML4TLogger("Visualizer")++ def plot_portfolio_performance(self, backtest_results: Dict, benchmark_data: pd.DataFrame = None):+ """Plot portfolio performance with benchmarks"""++ fig = make_subplots(+ rows=3, cols=2,+ subplot_titles=['Portfolio Value', 'Returns Distribution',+ 'Drawdown', 'Rolling Sharpe Ratio',+ 'Trade Analysis', 'Feature Importance'],+ specs=[[{"secondary_y": False}, {"secondary_y": False}],+ [{"secondary_y": False}, {"secondary_y": False}],+ [{"secondary_y": False}, {"secondary_y": False}]]+ )++ # Portfolio value+ dates = pd.to_datetime(backtest_results['dates'])+ portfolio_values = backtest_results['portfolio_values'][1:] # Remove initial value++ fig.add_trace(+ go.Scatter(x=dates, y=portfolio_values, name='Portfolio', line=dict(color='blue')),+ row=1, col=1+ )++ # Returns distribution+ returns = backtest_results['returns']+ fig.add_trace(+ go.Histogram(x=returns, name='Returns', nbinsx=50, opacity=0.7),+ row=1, col=2+ )++ # Drawdown+ cumulative_returns = (1 + returns).cumprod()+ rolling_max = cumulative_returns.expanding().max()+ drawdown = (cumulative_returns - rolling_max) / rolling_max++ fig.add_trace(+ go.Scatter(x=dates[1:], y=drawdown * 100, name='Drawdown %',+ fill='tonexty', line=dict(color='red')),+ row=2, col=1+ )++ # Rolling Sharpe ratio+ rolling_sharpe = returns.rolling(window=252).mean() / returns.rolling(window=252).std() * np.sqrt(252)+ fig.add_trace(+ go.Scatter(x=dates[1:], y=rolling_sharpe, name='Rolling Sharpe', line=dict(color='green')),+ row=2, col=2+ )++ # Trade analysis+ trades_df = pd.DataFrame(backtest_results['trades'])+ if not trades_df.empty:+ trade_pnl = trades_df.groupby('date')['value'].sum()+ fig.add_trace(+ go.Bar(x=trade_pnl.index, y=trade_pnl.values, name='Daily P&L'),+ row=3, col=1+ )++ fig.update_layout(height=1200, title_text="Portfolio Performance Dashboard")+ fig.show()++ def plot_factor_analysis(self, factor_performance: Dict):+ """Plot factor analysis results"""++ fig = make_subplots(+ rows=2, cols=2,+ subplot_titles=['Factor Returns by Quintile', 'Information Coefficient Over Time',+ 'Factor Distribution', 'Cumulative Factor Returns']+ )++ # Factor returns by quintile+ quintiles = list(factor_performance['quintile_returns'].keys())+ returns = list(factor_performance['quintile_returns'].values())++ fig.add_trace(+ go.Bar(x=quintiles, y=returns, name='Quintile Returns'),+ row=1, col=1+ )++ # Add other factor analysis plots here...++ fig.update_layout(height=800, title_text="Factor Analysis Dashboard")+ fig.show()++ def plot_model_performance(self, walk_forward_results: Dict):+ """Plot model performance over time"""++ results = walk_forward_results['results']++ # Extract metrics over time+ dates = [r['test_start'] for r in results]+ metrics = [r['metrics'] for r in results]++ fig = make_subplots(+ rows=2, cols=2,+ subplot_titles=['Model Accuracy Over Time', 'Prediction vs Actual',+ 'Feature Importance', 'Residual Analysis']+ )++ # Model performance over time+ if 'accuracy' in metrics[0]:+ accuracy_scores = [m['accuracy'] for m in metrics]+ fig.add_trace(+ go.Scatter(x=dates, y=accuracy_scores, name='Accuracy', line=dict(color='blue')),+ row=1, col=1+ )+ elif 'r2' in metrics[0]:+ r2_scores = [m['r2'] for m in metrics]+ fig.add_trace(+ go.Scatter(x=dates, y=r2_scores, name='R²', line=dict(color='blue')),+ row=1, col=1+ )++ # Prediction vs Actual scatter plot+ all_predictions = np.concatenate([r['predictions'] for r in results])+ all_actual = np.concatenate([r['actual'] for r in results])++ fig.add_trace(+ go.Scatter(x=all_actual, y=all_predictions, mode='markers',+ name='Pred vs Actual', opacity=0.6),+ row=1, col=2+ )++ # Add diagonal line for perfect predictions+ min_val, max_val = min(all_actual.min(), all_predictions.min()), max(all_actual.max(), all_predictions.max())+ fig.add_trace(+ go.Scatter(x=[min_val, max_val], y=[min_val, max_val],+ mode='lines', name='Perfect Prediction', line=dict(color='red', dash='dash')),+ row=1, col=2+ )++ fig.update_layout(height=800, title_text="Model Performance Analysis")+ fig.show()++# ============================================================================+# MAIN ML4T ORCHESTRATOR+# ============================================================================++class ML4TFramework:+ """Main orchestrator for the ML4T framework"""++ def __init__(self, config: ML4TConfig = None):+ self.config = config or ML4TConfig()+ self.logger = ML4TLogger("ML4TFramework")++ # Initialize components+ self.data_manager = DataManager(self.config)+ self.alpha_engine = AlphaFactorEngine(self.config)+ self.portfolio_optimizer = PortfolioOptimizer(self.config)+ self.backtest_engine = BacktestEngine(self.config)+ self.visualizer = ML4TVisualizer(self.config)++ # Storage for results+ self.data = {}+ self.factors = {}+ self.models = {}+ self.strategies = {}+ self.results = {}++ def load_data(self, symbols: List[str], start_date: str, end_date: str,+ include_fundamental: bool = True, include_alternative: bool = True):+ """Load all required data"""++ self.logger.info("Loading market data...")+ self.data['market'] = self.data_manager.load_market_data(symbols, start_date, end_date)++ if include_fundamental:+ self.logger.info("Loading fundamental data...")+ self.data['fundamental'] = self.data_manager.load_fundamental_data(symbols)++ if include_alternative:+ self.logger.info("Loading alternative data...")+ self.data['alternative'] = {+ 'sentiment': self.data_manager.load_alternative_data('sentiment'),+ 'social': self.data_manager.load_alternative_data('social')+ }++ def engineer_features(self, symbols: List[str]):+ """Generate comprehensive feature set"""++ self.logger.info("Engineering features...")++ all_features = []++ for symbol in symbols:+ # Technical factors+ technical_data = self.alpha_engine.calculate_technical_factors(self.data['market'], symbol)++ # Fundamental factors+ if 'fundamental' in self.data:+ fundamental_data = self.alpha_engine.calculate_fundamental_factors(+ technical_data, self.data['fundamental']+ )+ else:+ fundamental_data = technical_data++ # Alternative data factors+ if 'alternative' in self.data:+ final_data = self.alpha_engine.calculate_alternative_factors(+ fundamental_data, self.data['alternative']+ )+ else:+ final_data = fundamental_data++ all_features.append(final_data)++ self.factors['engineered'] = pd.concat(all_features, ignore_index=True)++ # Create target variable (future returns)+ self.factors['engineered'] = self.factors['engineered'].sort_values(['symbol', 'date'])+ self.factors['engineered']['future_returns'] = self.factors['engineered'].groupby('symbol')['returns'].shift(-1)++ # Remove rows with missing target+ self.factors['engineered'] = self.factors['engineered'].dropna(subset=['future_returns'])++ return self.factors['engineered']++ def train_models(self, feature_data: pd.DataFrame, models_config: List[Dict]):+ """Train multiple ML models"""++ self.logger.info("Training models...")++ # Prepare features and target+ feature_columns = [col for col in feature_data.columns+ if col not in ['date', 'symbol', 'future_returns', 'open', 'high', 'low', 'close', 'volume']]++ X = feature_data[feature_columns].fillna(0)+ y = feature_data['future_returns'].fillna(0)++ # Train each model+ for model_config in models_config:+ model_name = model_config['name']+ model_type = model_config['type']+ model_params = model_config.get('params', {})++ self.logger.info(f"Training {model_name} ({model_type})...")++ if model_type in ['linear', 'ridge', 'lasso', 'logistic']:+ model = LinearModel(self.config, model_type, **model_params)+ elif model_type in ['random_forest', 'gradient_boosting']:+ model = TreeBasedModel(self.config, model_type, **model_params)+ elif model_type in ['arima']:+ model = TimeSeriesModel(self.config, model_type, **model_params)+ else:+ self.logger.warning(f"Unknown model type: {model_type}")+ continue++ # Train model+ model.fit(X, y)+ self.models[model_name] = model++ self.logger.info(f"Model {model_name} trained successfully")++ def create_strategies(self, strategy_configs: List[Dict]):+ """Create trading strategies"""++ self.logger.info("Creating strategies...")++ for strategy_config in strategy_configs:+ strategy_name = strategy_config['name']+ strategy_type = strategy_config['type']+ strategy_params = strategy_config.get('params', {})++ if strategy_type == 'mean_reversion':+ strategy = MeanReversionStrategy(self.config, **strategy_params)+ elif strategy_type == 'momentum':+ strategy = MomentumStrategy(self.config, **strategy_params)+ elif strategy_type == 'ml_strategy':+ model_name = strategy_params.get('model_name')+ if model_name in self.models:+ features = strategy_params.get('features', [])+ strategy = MLStrategy(self.config, self.models[model_name], features)+ else:+ self.logger.warning(f"Model {model_name} not found for ML strategy")+ continue+ else:+ self.logger.warning(f"Unknown strategy type: {strategy_type}")+ continue++ self.strategies[strategy_name] = strategy+ self.logger.info(f"Strategy {strategy_name} created successfully")++ def run_backtests(self):+ """Run backtests for all strategies"""++ self.logger.info("Running backtests...")++ for strategy_name, strategy in self.strategies.items():+ self.logger.info(f"Backtesting strategy: {strategy_name}")++ # Generate signals+ signals = strategy.generate_signals(self.factors['engineered'])++ # Run backtest+ backtest_results = self.backtest_engine.run_backtest(+ signals, self.data['market'], self.config.initial_capital+ )++ self.results[strategy_name] = backtest_results++ # Log performance summary+ metrics = backtest_results['metrics']+ self.logger.info(f"Strategy {strategy_name} - Sharpe: {metrics['sharpe_ratio']:.3f}, "+ f"Return: {metrics['annualized_return']:.3f}, "+ f"MaxDD: {metrics['max_drawdown']:.3f}")++ def generate_report(self):+ """Generate comprehensive performance report"""++ self.logger.info("Generating performance report...")++ # Create summary report+ summary_data = []++ for strategy_name, results in self.results.items():+ metrics = results['metrics']+ summary_data.append({+ 'Strategy': strategy_name,+ 'Total Return': f"{metrics['total_return']:.2%}",+ 'Annualized Return': f"{metrics['annualized_return']:.2%}",+ 'Volatility': f"{metrics['annualized_volatility']:.2%}",+ 'Sharpe Ratio': f"{metrics['sharpe_ratio']:.3f}",+ 'Max Drawdown': f"{metrics['max_drawdown']:.2%}",+ 'Calmar Ratio': f"{metrics['calmar_ratio']:.3f}"+ })++ summary_df = pd.DataFrame(summary_data)++ print("\n" + "="*80)+ print("ML4T FRAMEWORK - PERFORMANCE SUMMARY")+ print("="*80)+ print(summary_df.to_string(index=False))+ print("="*80)++ return summary_df++ def visualize_results(self, strategy_name: str = None):+ """Create visualizations for results"""++ if strategy_name is None:+ # Show all strategies+ for name in self.results.keys():+ self.visualizer.plot_portfolio_performance(self.results[name])+ else:+ if strategy_name in self.results:+ self.visualizer.plot_portfolio_performance(self.results[strategy_name])+ else:+ self.logger.warning(f"Strategy {strategy_name} not found in results")++# ============================================================================+# EXAMPLE USAGE AND DEMO+# ============================================================================++def run_ml4t_demo():+ """Demonstration of the ML4T framework"""++ print("Initializing ML4T Framework...")++ # Initialize framework+ config = ML4TConfig()+ ml4t = ML4TFramework(config)++ # Define universe+ symbols = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA']+ start_date = '2020-01-01'+ end_date = '2023-12-31'++ # Load data+ ml4t.load_data(symbols, start_date, end_date)++ # Engineer features+ feature_data = ml4t.engineer_features(symbols)++ # Define models to train+ models_config = [+ {'name': 'ridge_model', 'type': 'ridge', 'params': {'alpha': 1.0}},+ {'name': 'random_forest', 'type': 'random_forest', 'params': {'n_estimators': 100}},+ {'name': 'gradient_boosting', 'type': 'gradient_boosting', 'params': {'n_estimators': 100}}+ ]++ # Train models+ ml4t.train_models(feature_data, models_config)++ # Define strategies+ feature_columns = [col for col in feature_data.columns+ if col not in ['date', 'symbol', 'future_returns', 'open', 'high', 'low', 'close', 'volume']]++ strategies_config = [+ {'name': 'mean_reversion', 'type': 'mean_reversion', 'params': {'lookback_window': 20}},+ {'name': 'momentum', 'type': 'momentum', 'params': {'lookback_window': 12}},+ {'name': 'ml_ridge', 'type': 'ml_strategy', 'params': {'model_name': 'ridge_model', 'features': feature_columns[:10]}},+ {'name': 'ml_rf', 'type': 'ml_strategy', 'params': {'model_name': 'random_forest', 'features': feature_columns[:10]}}+ ]++ # Create strategies+ ml4t.create_strategies(strategies_config)++ # Run backtests+ ml4t.run_backtests()++ # Generate report+ summary = ml4t.generate_report()++ return ml4t, summary++if __name__ == "__main__":+ # Run demonstration+ framework, results = run_ml4t_demo()+ print("\nML4T Framework demonstration completed successfully!")+ print("Access the framework object to explore individual components and results.")\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/requirements.txt b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/requirements.txtnew file mode 100644index 000000000..a502c3397--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/requirements.txt@@ -0,0 +1,2 @@+requests>=2.25.0+python-dotenv>=0.19.0 # Optional, for .env file support\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/test_client.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/test_client.pynew file mode 100644index 000000000..a07194086--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/ml4Trading/test_client.py@@ -0,0 +1,184 @@++Machine Learning Test Client Module+======================================++Testing client for ML trading strategies++===== DATA SOURCES REQUIRED =====+INPUT:+ - Historical market data and price time series+ - Technical indicators and market features+ - Alternative data sources (news, sentiment, etc.)+ - Market microstructure data and order flow+ - Economic indicators and macro data++OUTPUT:+ - Machine learning models for price prediction+ - Trading signals and strategy recommendations+ - Risk forecasts and position sizing suggestions+ - Performance metrics and backtest results+ - Feature importance and model interpretability++PARAMETERS:+ - model_type: Machine learning algorithm (default: 'random_forest')+ - training_window: Training data window size (default: 252 days)+ - prediction_horizon: Prediction horizon (default: 1 day)+ - feature_selection: Feature selection method (default: 'recursive')+ - validation_method: Model validation approach (default: 'time_series_split')+++#!/usr/bin/env python3+"""+Test script for the enhanced OpenRouter API client+Run this to verify your setup and test basic functionality+"""++import os+import sys+from dotenv import load_dotenv+from kimi2 import OpenRouterClient, OpenRouterConfig++def test_setup():+ """Test basic setup and configuration"""+ print("=== Testing OpenRouter Client Setup ===")++ # Load environment variables+ load_dotenv()++ # Check for API key+ api_key = os.getenv("OPENROUTER_API_KEY")+ if not api_key:+ print("❌ FAIL: OPENROUTER_API_KEY environment variable not found")+ print("Please create a .env file based on .env.example")+ return False+ else:+ print("✅ PASS: API key found in environment")++ # Test client initialization+ try:+ config = OpenRouterConfig(max_retries=1) # Quick test with fewer retries+ client = OpenRouterClient(api_key=api_key, config=config)+ print("✅ PASS: Client initialization successful")+ except Exception as e:+ print(f"❌ FAIL: Client initialization failed: {e}")+ return False++ return True++def test_api_call():+ """Test actual API call with a simple request"""+ print("\n=== Testing API Call ===")++ try:+ # Load environment variables+ load_dotenv()+ api_key = os.getenv("OPENROUTER_API_KEY")++ if not api_key:+ print("❌ SKIPPED: API key not configured")+ return False++ # Initialize client with minimal config for testing+ config = OpenRouterConfig(timeout=30, max_retries=2)+ client = OpenRouterClient(api_key=api_key, config=config)++ # Make a simple test call+ messages = [{"role": "user", "content": "Say 'Hello from test client' and count to 3."}]++ print("Making test API call...")+ response = client.chat_completion(messages, max_tokens=50)++ # Validate response+ if response and "choices" in response:+ print("✅ PASS: API call successful")++ # Show response+ if len(response["choices"]) > 0:+ content = response["choices"][0].get("message", {}).get("content", "")+ print(f"Response: {content[:100]}...") # First 100 chars+ return True+ else:+ print("❌ FAIL: Invalid response structure")+ return False++ except requests.exceptions.RequestException as e:+ print(f"❌ FAIL: Network error during API call: {e}")+ return False+ except Exception as e:+ print(f"❌ FAIL: Unexpected error during API call: {e}")+ return False++def test_error_handling():+ """Test error handling scenarios"""+ print("\n=== Testing Error Handling ===")++ try:+ # Test without API key+ try:+ client = OpenRouterClient()+ print("❌ FAIL: Should have raised ValueError without API key")+ return False+ except ValueError as e:+ print("✅ PASS: Correctly raises ValueError without API key")++ # Test with invalid API key+ try:+ config = OpenRouterConfig(timeout=5, max_retries=1)+ client = OpenRouterClient(api_key="invalid-key", config=config)+ messages = [{"role": "user", "content": "test"}]+ client.chat_completion(messages)+ print("❌ FAIL: Should have failed with invalid API key")+ return False+ except requests.exceptions.RequestException:+ print("✅ PASS: Correctly handles invalid API key")++ return True++ except Exception as e:+ print(f"❌ FAIL: Error handling test failed: {e}")+ return False++def main():+ """Run all tests"""+ print("OpenRouter Client Test Suite")+ print("=" * 50)++ tests = [+ ("Setup Test", test_setup),+ ("Error Handling Test", test_error_handling),+ ("API Call Test", test_api_call)+ ]++ results = []++ for test_name, test_func in tests:+ try:+ result = test_func()+ results.append((test_name, result))+ except Exception as e:+ print(f"❌ FAIL: {test_name} raised exception: {e}")+ results.append((test_name, False))++ # Summary+ print("\n" + "=" * 50)+ print("Test Results Summary:")+ print("=" * 50)++ passed = sum(1 for _, result in results if result)+ total = len(results)++ for test_name, result in results:+ status = "✅ PASS" if result else "❌ FAIL"+ print(f"{status} {test_name}")++ print(f"\nResults: {passed}/{total} tests passed")++ if passed == total:+ print("🎉 All tests passed! Your setup is ready.")+ return 0+ else:+ print("⚠️ Some tests failed. Check the output above for details.")+ return 1++if __name__ == "__main__":+ sys.exit(main())\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/active_management.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/active_management.pynew file mode 100644index 000000000..fe245a0c9--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/active_management.py@@ -0,0 +1,1425 @@++Portfolio Active Management Module+===============================++Active portfolio management strategies++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple, Callable+from dataclasses import dataclass+from enum import Enum+import warnings++from config import MathConstants, validate_returns, ERROR_MESSAGES+from math_engine import StatisticalCalculations, PerformanceCalculations+++class ActiveStrategy(Enum):+ """Types of active management strategies"""+ MARKET_TIMING = "market_timing"+ SECURITY_SELECTION = "security_selection"+ SECTOR_ROTATION = "sector_rotation"+ STYLE_TILTING = "style_tilting"+ FACTOR_TIMING = "factor_timing"+++class FactorModelType(Enum):+ """Types of factor models"""+ MACROECONOMIC = "macroeconomic"+ FUNDAMENTAL = "fundamental"+ STATISTICAL = "statistical"+++@dataclass+class ActiveManagementMetrics:+ """Active management performance metrics"""+ active_return: float+ tracking_error: float+ information_ratio: float+ hit_rate: float+ active_risk: float+ transfer_coefficient: float+++class ValueAddedMeasurement:+ """Measurement of value added by active management"""++ @staticmethod+ def calculate_value_added(portfolio_returns: np.ndarray,+ benchmark_returns: np.ndarray,+ portfolio_weights: Optional[np.ndarray] = None) -> Dict:+ """Calculate value added by active management"""++ if not validate_returns(portfolio_returns) or not validate_returns(benchmark_returns):+ raise ValueError(ERROR_MESSAGES["insufficient_data"])++ # Active returns (excess returns over benchmark)+ active_returns = np.array(portfolio_returns) - np.array(benchmark_returns)++ # Basic value added metrics+ mean_active_return = np.mean(active_returns)+ tracking_error = np.std(active_returns, ddof=1)++ # Annualize metrics+ annualized_active_return = mean_active_return * MathConstants.TRADING_DAYS_YEAR+ annualized_tracking_error = tracking_error * MathConstants.SQRT_TRADING_DAYS++ # Information ratio+ information_ratio = mean_active_return / tracking_error if tracking_error > 0 else 0+ annualized_ir = information_ratio * MathConstants.SQRT_TRADING_DAYS++ # Hit rate (percentage of periods with positive active returns)+ hit_rate = np.sum(active_returns > 0) / len(active_returns)++ # Value added decomposition+ value_decomposition = ValueAddedMeasurement._decompose_value_added(+ portfolio_returns, benchmark_returns, portfolio_weights+ )++ return {+ "active_return_daily": mean_active_return,+ "active_return_annualized": annualized_active_return,+ "tracking_error_daily": tracking_error,+ "tracking_error_annualized": annualized_tracking_error,+ "information_ratio_daily": information_ratio,+ "information_ratio_annualized": annualized_ir,+ "hit_rate": hit_rate,+ "value_added_decomposition": value_decomposition,+ "statistical_significance": ValueAddedMeasurement._test_statistical_significance(+ active_returns+ )+ }++ @staticmethod+ def _decompose_value_added(portfolio_returns: np.ndarray,+ benchmark_returns: np.ndarray,+ portfolio_weights: Optional[np.ndarray]) -> Dict:+ """Decompose value added into sources"""++ # Simplified decomposition - in practice would need detailed holdings data+ total_active_return = np.mean(portfolio_returns) - np.mean(benchmark_returns)++ # Estimate allocation vs selection effects (simplified)+ # This would require sector/security level data in practice+ estimated_allocation_effect = total_active_return * 0.3 # Rough estimate+ estimated_selection_effect = total_active_return * 0.7 # Rough estimate++ return {+ "total_active_return": total_active_return * MathConstants.TRADING_DAYS_YEAR,+ "estimated_allocation_effect": estimated_allocation_effect * MathConstants.TRADING_DAYS_YEAR,+ "estimated_selection_effect": estimated_selection_effect * MathConstants.TRADING_DAYS_YEAR,+ "interaction_effect": 0.0, # Would calculate with detailed data+ "note": "Decomposition requires detailed holdings data for precision"+ }++ @staticmethod+ def _test_statistical_significance(active_returns: np.ndarray) -> Dict:+ """Test statistical significance of active returns"""++ mean_active = np.mean(active_returns)+ std_active = np.std(active_returns, ddof=1)+ n_periods = len(active_returns)++ # T-statistic for testing if mean active return is significantly different from zero+ t_statistic = mean_active / (std_active / np.sqrt(n_periods)) if std_active > 0 else 0++ # Critical values (approximate)+ critical_90 = 1.645+ critical_95 = 1.96+ critical_99 = 2.576++ significance_level = "Not significant"+ if abs(t_statistic) > critical_99:+ significance_level = "99% significant"+ elif abs(t_statistic) > critical_95:+ significance_level = "95% significant"+ elif abs(t_statistic) > critical_90:+ significance_level = "90% significant"++ return {+ "t_statistic": t_statistic,+ "significance_level": significance_level,+ "is_significant_95": abs(t_statistic) > critical_95,+ "sample_size": n_periods,+ "standard_error": std_active / np.sqrt(n_periods)+ }+++class InformationRatioAnalysis:+ """Information ratio calculation and analysis"""++ @staticmethod+ def calculate_information_ratio_ex_post(portfolio_returns: np.ndarray,+ benchmark_returns: np.ndarray) -> Dict:+ """Calculate ex-post (realized) information ratio"""++ active_returns = np.array(portfolio_returns) - np.array(benchmark_returns)++ mean_active_return = np.mean(active_returns)+ tracking_error = np.std(active_returns, ddof=1)++ # Information ratio+ ir_daily = mean_active_return / tracking_error if tracking_error > 0 else 0+ ir_annualized = ir_daily * MathConstants.SQRT_TRADING_DAYS++ # Compare to Sharpe ratio+ portfolio_sharpe = PerformanceCalculations.sharpe_ratio(portfolio_returns)+ benchmark_sharpe = PerformanceCalculations.sharpe_ratio(benchmark_returns)++ return {+ "information_ratio_daily": ir_daily,+ "information_ratio_annualized": ir_annualized,+ "active_return_annualized": mean_active_return * MathConstants.TRADING_DAYS_YEAR,+ "tracking_error_annualized": tracking_error * MathConstants.SQRT_TRADING_DAYS,+ "portfolio_sharpe_ratio": portfolio_sharpe,+ "benchmark_sharpe_ratio": benchmark_sharpe,+ "sharpe_ratio_difference": portfolio_sharpe - benchmark_sharpe,+ "ir_quality_assessment": InformationRatioAnalysis._assess_ir_quality(ir_annualized)+ }++ @staticmethod+ def calculate_information_ratio_ex_ante(expected_active_return: float,+ expected_tracking_error: float,+ forecast_horizon_months: int = 12) -> Dict:+ """Calculate ex-ante (expected) information ratio"""++ # Convert to appropriate time horizon+ time_factor = np.sqrt(forecast_horizon_months / 12)++ ex_ante_ir = expected_active_return / expected_tracking_error if expected_tracking_error > 0 else 0++ # Confidence intervals for ex-ante IR+ confidence_intervals = InformationRatioAnalysis._calculate_ir_confidence_intervals(+ ex_ante_ir, forecast_horizon_months+ )++ return {+ "ex_ante_information_ratio": ex_ante_ir,+ "expected_active_return": expected_active_return,+ "expected_tracking_error": expected_tracking_error,+ "forecast_horizon_months": forecast_horizon_months,+ "confidence_intervals": confidence_intervals,+ "probability_of_positive_alpha": InformationRatioAnalysis._probability_positive_alpha(+ expected_active_return, expected_tracking_error+ )+ }++ @staticmethod+ def compare_ir_to_sharpe(information_ratio: float,+ portfolio_sharpe: float,+ benchmark_sharpe: float) -> Dict:+ """Compare Information Ratio to Sharpe ratios"""++ # Theoretical relationship: IR measures active management skill+ # while Sharpe measures total risk-adjusted return++ analysis = {+ "information_ratio": information_ratio,+ "portfolio_sharpe": portfolio_sharpe,+ "benchmark_sharpe": benchmark_sharpe,+ "interpretation": {+ "ir_focus": "Measures excess return per unit of active risk",+ "sharpe_focus": "Measures excess return per unit of total risk",+ "complementary_nature": "Both metrics provide different insights into performance"+ }+ }++ # Practical interpretation+ if information_ratio > 0.5:+ analysis["ir_assessment"] = "Excellent active management"+ elif information_ratio > 0.25:+ analysis["ir_assessment"] = "Good active management"+ elif information_ratio > 0:+ analysis["ir_assessment"] = "Modest active management value"+ else:+ analysis["ir_assessment"] = "Value-destroying active management"++ return analysis++ @staticmethod+ def _assess_ir_quality(ir_annualized: float) -> Dict:+ """Assess quality of information ratio"""++ if ir_annualized > 0.75:+ quality = "Exceptional"+ percentile = "Top 5%"+ elif ir_annualized > 0.50:+ quality = "Excellent"+ percentile = "Top 10%"+ elif ir_annualized > 0.25:+ quality = "Good"+ percentile = "Top 25%"+ elif ir_annualized > 0:+ quality = "Below average"+ percentile = "Below median"+ else:+ quality = "Poor"+ percentile = "Bottom quartile"++ return {+ "quality_rating": quality,+ "industry_percentile": percentile,+ "sustainability_concern": ir_annualized > 1.0 # Very high IRs often not sustainable+ }++ @staticmethod+ def _calculate_ir_confidence_intervals(ir: float, horizon_months: int) -> Dict:+ """Calculate confidence intervals for information ratio"""++ # Standard error of IR (simplified)+ n_observations = horizon_months * 21 # Approximate daily observations+ ir_standard_error = np.sqrt((1 + ir ** 2 / 2) / n_observations)++ # 95% confidence interval+ margin_of_error = 1.96 * ir_standard_error++ return {+ "95_percent_confidence_interval": {+ "lower_bound": ir - margin_of_error,+ "upper_bound": ir + margin_of_error+ },+ "standard_error": ir_standard_error,+ "sample_size_effect": "Longer track records provide more reliable IR estimates"+ }++ @staticmethod+ def _probability_positive_alpha(expected_return: float, tracking_error: float) -> float:+ """Calculate probability of generating positive alpha"""++ if tracking_error <= 0:+ return 0.5++ # Assuming normal distribution+ from scipy import stats+ z_score = expected_return / tracking_error+ probability = stats.norm.cdf(z_score)++ return probability+++class FundamentalLawActiveManagement:+ """Fundamental Law of Active Management implementation"""++ @staticmethod+ def calculate_fundamental_law_components(portfolio_data: Dict) -> Dict:+ """Calculate components of the Fundamental Law of Active Management"""++ # Extract components+ information_coefficient = portfolio_data.get("information_coefficient", 0.05)+ breadth = portfolio_data.get("breadth", 100)+ transfer_coefficient = portfolio_data.get("transfer_coefficient", 0.8)+ active_risk = portfolio_data.get("active_risk", 0.04)++ # Calculate Information Ratio using Fundamental Law+ # IR = IC × √Breadth × TC+ fundamental_law_ir = information_coefficient * np.sqrt(breadth) * transfer_coefficient++ # Expected active return+ expected_active_return = fundamental_law_ir * active_risk++ return {+ "information_coefficient": information_coefficient,+ "breadth": breadth,+ "transfer_coefficient": transfer_coefficient,+ "active_risk": active_risk,+ "fundamental_law_ir": fundamental_law_ir,+ "expected_active_return": expected_active_return,+ "component_analysis": FundamentalLawActiveManagement._analyze_components(+ information_coefficient, breadth, transfer_coefficient+ )+ }++ @staticmethod+ def analyze_strategy_changes(current_strategy: Dict, proposed_strategy: Dict) -> Dict:+ """Analyze strategy changes in terms of Fundamental Law"""++ # Current strategy metrics+ current_ic = current_strategy.get("information_coefficient", 0.05)+ current_breadth = current_strategy.get("breadth", 100)+ current_tc = current_strategy.get("transfer_coefficient", 0.8)+ current_ir = current_ic * np.sqrt(current_breadth) * current_tc++ # Proposed strategy metrics+ proposed_ic = proposed_strategy.get("information_coefficient", 0.05)+ proposed_breadth = proposed_strategy.get("breadth", 100)+ proposed_tc = proposed_strategy.get("transfer_coefficient", 0.8)+ proposed_ir = proposed_ic * np.sqrt(proposed_breadth) * proposed_tc++ # Analysis of changes+ ir_change = proposed_ir - current_ir+ ir_change_pct = (ir_change / current_ir * 100) if current_ir != 0 else 0++ # Component contributions to change+ component_contributions = FundamentalLawActiveManagement._decompose_ir_change(+ current_strategy, proposed_strategy+ )++ return {+ "current_strategy_ir": current_ir,+ "proposed_strategy_ir": proposed_ir,+ "ir_change": ir_change,+ "ir_change_percentage": ir_change_pct,+ "component_contributions": component_contributions,+ "recommendation": FundamentalLawActiveManagement._generate_strategy_recommendation(+ ir_change, component_contributions+ )+ }++ @staticmethod+ def market_timing_vs_security_selection(market_timing_data: Dict,+ security_selection_data: Dict) -> Dict:+ """Compare market timing vs security selection strategies"""++ # Market timing analysis+ mt_ic = market_timing_data.get("information_coefficient", 0.1) # Higher IC, lower breadth+ mt_breadth = market_timing_data.get("breadth", 12) # Monthly decisions+ mt_tc = market_timing_data.get("transfer_coefficient", 0.9)+ mt_ir = mt_ic * np.sqrt(mt_breadth) * mt_tc++ # Security selection analysis+ ss_ic = security_selection_data.get("information_coefficient", 0.03) # Lower IC, higher breadth+ ss_breadth = security_selection_data.get("breadth", 500) # Many securities+ ss_tc = security_selection_data.get("transfer_coefficient", 0.7)+ ss_ir = ss_ic * np.sqrt(ss_breadth) * ss_tc++ comparison = {+ "market_timing": {+ "information_coefficient": mt_ic,+ "breadth": mt_breadth,+ "transfer_coefficient": mt_tc,+ "information_ratio": mt_ir,+ "characteristics": "High skill, low breadth, high implementation efficiency"+ },+ "security_selection": {+ "information_coefficient": ss_ic,+ "breadth": ss_breadth,+ "transfer_coefficient": ss_tc,+ "information_ratio": ss_ir,+ "characteristics": "Moderate skill, high breadth, good implementation"+ },+ "comparison_insights": {+ "higher_ir_strategy": "Market Timing" if mt_ir > ss_ir else "Security Selection",+ "breadth_vs_skill_tradeoff": "Market timing requires higher skill but offers lower breadth",+ "implementation_challenges": FundamentalLawActiveManagement._compare_implementation_challenges()+ }+ }++ return comparison++ @staticmethod+ def _analyze_components(ic: float, breadth: float, tc: float) -> Dict:+ """Analyze individual components of the Fundamental Law"""++ return {+ "information_coefficient_analysis": {+ "value": ic,+ "interpretation": "High" if ic > 0.1 else "Moderate" if ic > 0.05 else "Low",+ "improvement_potential": "Skill development, better research, improved models",+ "typical_range": "0.02 to 0.15 for most active managers"+ },+ "breadth_analysis": {+ "value": breadth,+ "interpretation": "High" if breadth > 200 else "Moderate" if breadth > 50 else "Low",+ "improvement_potential": "Expand universe, increase decision frequency",+ "trade_offs": "More breadth may reduce IC if skill is diluted"+ },+ "transfer_coefficient_analysis": {+ "value": tc,+ "interpretation": "High" if tc > 0.8 else "Moderate" if tc > 0.6 else "Low",+ "improvement_potential": "Reduce constraints, improve implementation",+ "constraints_impact": "Benchmarking, risk limits, liquidity affect TC"+ }+ }++ @staticmethod+ def _decompose_ir_change(current: Dict, proposed: Dict) -> Dict:+ """Decompose change in IR into component contributions"""++ # Calculate marginal contribution of each component+ # This is a simplified linear approximation++ current_ic = current.get("information_coefficient", 0.05)+ current_breadth = current.get("breadth", 100)+ current_tc = current.get("transfer_coefficient", 0.8)++ proposed_ic = proposed.get("information_coefficient", 0.05)+ proposed_breadth = proposed.get("breadth", 100)+ proposed_tc = proposed.get("transfer_coefficient", 0.8)++ # Marginal contributions (approximate)+ ic_contribution = (proposed_ic - current_ic) * np.sqrt(current_breadth) * current_tc+ breadth_contribution = current_ic * (np.sqrt(proposed_breadth) - np.sqrt(current_breadth)) * current_tc+ tc_contribution = current_ic * np.sqrt(current_breadth) * (proposed_tc - current_tc)++ return {+ "ic_contribution": ic_contribution,+ "breadth_contribution": breadth_contribution,+ "tc_contribution": tc_contribution,+ "total_change": ic_contribution + breadth_contribution + tc_contribution,+ "largest_contributor": max([+ ("IC", ic_contribution),+ ("Breadth", breadth_contribution),+ ("TC", tc_contribution)+ ], key=lambda x: abs(x[1]))[0]+ }+++class MultifactorModels:+ """Multifactor models implementation and analysis"""++ @staticmethod+ def arbitrage_pricing_theory_analysis() -> Dict:+ """Analyze Arbitrage Pricing Theory and its assumptions"""++ return {+ "apt_assumptions": {+ "factor_model": "Returns generated by linear factor model",+ "diversification": "Unsystematic risk can be diversified away",+ "no_arbitrage": "No arbitrage opportunities exist in equilibrium",+ "competitive_markets": "Markets are competitive with rational investors"+ },+ "apt_equation": {+ "mathematical_form": "E(Ri) = λ0 + λ1*βi1 + λ2*βi2 + ... + λk*βik",+ "components": {+ "E(Ri)": "Expected return on asset i",+ "λ0": "Risk-free rate or factor risk premium for λ0",+ "λj": "Risk premium for factor j",+ "βij": "Sensitivity of asset i to factor j"+ }+ },+ "relationship_to_multifactor_models": {+ "apt_foundation": "APT provides theoretical foundation for multifactor models",+ "practical_implementation": "Multifactor models are practical implementations of APT",+ "factor_identification": "APT doesn't specify factors; models must identify relevant factors"+ },+ "advantages": [+ "More general than CAPM",+ "Allows for multiple risk factors",+ "No specific utility function required",+ "Fewer restrictive assumptions than CAPM"+ ],+ "limitations": [+ "Doesn't specify which factors to use",+ "Factor risk premiums must be estimated",+ "Requires large portfolios for diversification assumption",+ "Testing APT is challenging empirically"+ ]+ }++ @staticmethod+ def identify_arbitrage_opportunity(expected_returns: np.ndarray,+ factor_loadings: np.ndarray,+ factor_risk_premiums: np.ndarray,+ risk_free_rate: float = 0.03) -> Dict:+ """Identify arbitrage opportunities using APT"""++ # Calculate APT-implied expected returns+ apt_expected_returns = risk_free_rate + np.dot(factor_loadings, factor_risk_premiums)++ # Compare with market expected returns+ return_differences = expected_returns - apt_expected_returns++ # Identify potential arbitrage opportunities+ arbitrage_opportunities = []++ for i, diff in enumerate(return_differences):+ if abs(diff) > 0.005: # 0.5% threshold for significance+ arbitrage_opportunities.append({+ "asset_index": i,+ "expected_return": expected_returns[i],+ "apt_fair_value": apt_expected_returns[i],+ "difference": diff,+ "direction": "Overvalued" if diff < 0 else "Undervalued",+ "arbitrage_potential": abs(diff)+ })++ return {+ "arbitrage_opportunities": arbitrage_opportunities,+ "number_of_opportunities": len(arbitrage_opportunities),+ "largest_opportunity": max(arbitrage_opportunities,+ key=lambda x: x["arbitrage_potential"]) if arbitrage_opportunities else None,+ "market_efficiency_assessment": MultifactorModels._assess_market_efficiency(return_differences)+ }++ @staticmethod+ def calculate_expected_return_multifactor(factor_sensitivities: np.ndarray,+ factor_risk_premiums: np.ndarray,+ risk_free_rate: float = 0.03) -> Dict:+ """Calculate expected return using multifactor model"""++ # E(R) = Rf + β1*RP1 + β2*RP2 + ... + βk*RPk+ factor_contributions = factor_sensitivities * factor_risk_premiums+ total_risk_premium = np.sum(factor_contributions)+ expected_return = risk_free_rate + total_risk_premium++ return {+ "expected_return": expected_return,+ "risk_free_rate": risk_free_rate,+ "total_risk_premium": total_risk_premium,+ "factor_contributions": {+ f"factor_{i + 1}": {+ "sensitivity": factor_sensitivities[i],+ "risk_premium": factor_risk_premiums[i],+ "contribution": factor_contributions[i]+ }+ for i in range(len(factor_sensitivities))+ },+ "decomposition_analysis": MultifactorModels._analyze_return_decomposition(+ factor_contributions, total_risk_premium+ )+ }++ @staticmethod+ def compare_factor_models() -> Dict:+ """Compare different types of factor models"""++ return {+ "macroeconomic_factor_models": {+ "description": "Use observable economic variables as factors",+ "examples": ["GDP growth", "Inflation", "Interest rates", "Oil prices"],+ "advantages": [+ "Intuitive economic interpretation",+ "Factors are observable",+ "Good for scenario analysis",+ "Useful for risk management"+ ],+ "disadvantages": [+ "May miss important risk factors",+ "Economic factors may be correlated",+ "Factor loadings must be estimated",+ "Limited number of factors"+ ],+ "typical_applications": ["Asset allocation", "Risk management", "Scenario analysis"]+ },+ "fundamental_factor_models": {+ "description": "Use company/security fundamental attributes as factors",+ "examples": ["P/E ratio", "Book-to-market", "Market cap", "Earnings growth"],+ "advantages": [+ "Factors directly observable from financial data",+ "Good for security selection",+ "Many factors can be included",+ "Useful for portfolio construction"+ ],+ "disadvantages": [+ "Factor returns must be estimated",+ "May have multicollinearity issues",+ "Requires frequent factor updating",+ "Survivorship bias in factor construction"+ ],+ "typical_applications": ["Security selection", "Portfolio construction", "Performance attribution"]+ },+ "statistical_factor_models": {+ "description": "Use statistical techniques to extract factors from return data",+ "examples": ["Principal component analysis", "Factor analysis", "Independent component analysis"],+ "advantages": [+ "Factors explain maximum return variation",+ "No need to specify factors a priori",+ "Factors are orthogonal",+ "Good statistical properties"+ ],+ "disadvantages": [+ "Factors lack economic interpretation",+ "Factors may be unstable over time",+ "Difficult to use for forecasting",+ "Black box approach"+ ],+ "typical_applications": ["Risk modeling", "Portfolio optimization", "Performance measurement"]+ }+ }++ @staticmethod+ def analyze_multifactor_model_uses(portfolio_data: Dict) -> Dict:+ """Analyze uses of multifactor models"""++ uses = {+ "risk_management": {+ "description": "Decompose portfolio risk into factor exposures",+ "applications": [+ "Track factor exposures relative to benchmark",+ "Identify concentrated factor bets",+ "Stress test portfolio under factor scenarios",+ "Set factor exposure limits"+ ],+ "example_analysis": MultifactorModels._example_risk_decomposition(portfolio_data)+ },+ "portfolio_construction": {+ "description": "Build portfolios with desired factor exposures",+ "applications": [+ "Optimize portfolio for factor exposures",+ "Create factor-neutral portfolios",+ "Implement factor tilts",+ "Control unintended factor bets"+ ],+ "optimization_considerations": [+ "Transaction costs and turnover",+ "Factor exposure constraints",+ "Risk budgeting across factors",+ "Implementation efficiency"+ ]+ },+ "performance_attribution": {+ "description": "Attribute portfolio performance to factor exposures",+ "applications": [+ "Separate alpha from factor returns",+ "Identify sources of outperformance",+ "Evaluate manager skill vs factor timing",+ "Benchmark factor-adjusted performance"+ ],+ "attribution_framework": MultifactorModels._performance_attribution_framework()+ }+ }++ return uses++ @staticmethod+ def multiple_risk_dimensions_benefits() -> Dict:+ """Describe benefits of considering multiple risk dimensions"""++ return {+ "comprehensive_risk_capture": {+ "single_factor_limitations": "Single factor (like market beta) may miss important risks",+ "multifactor_advantages": "Captures various sources of systematic risk",+ "risk_factor_examples": [+ "Market risk (beta)",+ "Size risk (small vs large cap)",+ "Value risk (value vs growth)",+ "Momentum risk",+ "Quality risk",+ "Volatility risk"+ ]+ },+ "improved_risk_measurement": {+ "better_diversification_assessment": "Identifies true diversification vs correlated factor exposures",+ "concentrated_risk_identification": "Reveals hidden concentrations in factor exposures",+ "stress_testing_enhancement": "Enables factor-based scenario analysis",+ "tail_risk_modeling": "Better modeling of extreme events through factor interactions"+ },+ "enhanced_portfolio_construction": {+ "factor_based_allocation": "Allocate risk budget across multiple factors",+ "smart_beta_implementation": "Systematic factor exposure implementation",+ "alpha_separation": "Separate factor returns from true alpha generation",+ "benchmark_relative_positioning": "Control factor exposures relative to benchmark"+ },+ "practical_applications": {+ "asset_allocation": "Factor-based strategic asset allocation",+ "security_selection": "Factor-aware security selection process",+ "risk_budgeting": "Allocate risk across factors rather than just assets",+ "performance_evaluation": "Factor-adjusted performance measurement"+ }+ }++ @staticmethod+ def _assess_market_efficiency(return_differences: np.ndarray) -> Dict:+ """Assess market efficiency based on APT deviations"""++ abs_differences = np.abs(return_differences)+ mean_abs_difference = np.mean(abs_differences)+ max_abs_difference = np.max(abs_differences)++ if mean_abs_difference < 0.01:+ efficiency = "High"+ assessment = "Market appears highly efficient"+ elif mean_abs_difference < 0.02:+ efficiency = "Moderate"+ assessment = "Some inefficiencies present"+ else:+ efficiency = "Low"+ assessment = "Significant inefficiencies detected"++ return {+ "efficiency_level": efficiency,+ "assessment": assessment,+ "mean_absolute_deviation": mean_abs_difference,+ "maximum_deviation": max_abs_difference,+ "number_of_large_deviations": np.sum(abs_differences > 0.02)+ }+++class ActiveRiskTracking:+ """Active risk sources and tracking analysis"""++ @staticmethod+ def decompose_active_risk(portfolio_weights: np.ndarray,+ benchmark_weights: np.ndarray,+ factor_exposures: np.ndarray,+ factor_covariance: np.ndarray,+ specific_risk: np.ndarray) -> Dict:+ """Decompose active risk into factor and specific components"""++ # Active weights+ active_weights = portfolio_weights - benchmark_weights++ # Factor risk contribution+ portfolio_factor_exposure = np.dot(active_weights, factor_exposures)+ factor_risk = np.sqrt(np.dot(portfolio_factor_exposure,+ np.dot(factor_covariance, portfolio_factor_exposure)))++ # Specific risk contribution+ specific_risk_contribution = np.sqrt(np.dot(active_weights ** 2, specific_risk ** 2))++ # Total active risk (simplified - ignoring factor-specific correlation)+ total_active_risk = np.sqrt(factor_risk ** 2 + specific_risk_contribution ** 2)++ return {+ "total_active_risk": total_active_risk,+ "factor_risk_contribution": factor_risk,+ "specific_risk_contribution": specific_risk_contribution,+ "factor_risk_percentage": (factor_risk / total_active_risk) * 100 if total_active_risk > 0 else 0,+ "specific_risk_percentage": (+ specific_risk_contribution / total_active_risk) * 100 if total_active_risk > 0 else 0,+ "risk_decomposition_analysis": ActiveRiskTracking._analyze_risk_decomposition(+ factor_risk, specific_risk_contribution, total_active_risk+ )+ }++ @staticmethod+ def calculate_tracking_risk(portfolio_returns: np.ndarray,+ benchmark_returns: np.ndarray,+ rolling_window: int = 252) -> Dict:+ """Calculate tracking risk with rolling analysis"""++ active_returns = portfolio_returns - benchmark_returns++ # Overall tracking risk+ tracking_risk = np.std(active_returns, ddof=1) * MathConstants.SQRT_TRADING_DAYS++ # Rolling tracking risk+ rolling_tracking_risk = []+ for i in range(rolling_window, len(active_returns)):+ window_returns = active_returns[i - rolling_window:i]+ rolling_te = np.std(window_returns, ddof=1) * MathConstants.SQRT_TRADING_DAYS+ rolling_tracking_risk.append(rolling_te)++ rolling_tracking_risk = np.array(rolling_tracking_risk)++ return {+ "tracking_risk_annualized": tracking_risk,+ "rolling_tracking_risk": rolling_tracking_risk,+ "tracking_risk_statistics": {+ "mean_rolling_te": np.mean(rolling_tracking_risk),+ "std_rolling_te": np.std(rolling_tracking_risk),+ "min_rolling_te": np.min(rolling_tracking_risk),+ "max_rolling_te": np.max(rolling_tracking_risk)+ },+ "tracking_risk_stability": ActiveRiskTracking._assess_tracking_risk_stability(+ rolling_tracking_risk+ ),+ "active_return_analysis": ActiveRiskTracking._analyze_active_returns(active_returns)+ }++ @staticmethod+ def sources_of_active_risk() -> Dict:+ """Identify and explain sources of active risk"""++ return {+ "asset_allocation_risk": {+ "description": "Risk from deviating from benchmark asset allocation",+ "sources": [+ "Sector allocation differences",+ "Geographic allocation differences",+ "Style allocation differences",+ "Market cap allocation differences"+ ],+ "measurement": "Track active weights in each allocation dimension",+ "management": "Set allocation limits and monitor regularly"+ },+ "security_selection_risk": {+ "description": "Risk from selecting different securities within allocations",+ "sources": [+ "Stock picking within sectors",+ "Bond selection within duration/credit buckets",+ "Overweight/underweight individual positions",+ "Security-specific events"+ ],+ "measurement": "Analyze stock-specific active weights and performance",+ "management": "Diversification limits and position sizing rules"+ },+ "factor_exposure_risk": {+ "description": "Risk from different factor exposures vs benchmark",+ "sources": [+ "Value vs growth tilt",+ "Size factor exposure",+ "Quality factor exposure",+ "Momentum factor exposure",+ "Volatility factor exposure"+ ],+ "measurement": "Factor exposure analysis vs benchmark",+ "management": "Factor exposure limits and hedging"+ },+ "timing_risk": {+ "description": "Risk from timing allocation and selection decisions",+ "sources": [+ "Market timing attempts",+ "Sector rotation timing",+ "Entry/exit timing for positions",+ "Rebalancing timing"+ ],+ "measurement": "Performance attribution across time periods",+ "management": "Systematic processes and reduced discretionary timing"+ }+ }++ @staticmethod+ def _analyze_risk_decomposition(factor_risk: float, specific_risk: float,+ total_risk: float) -> Dict:+ """Analyze the risk decomposition results"""++ factor_dominance = factor_risk > specific_risk++ analysis = {+ "dominant_risk_source": "Factor Risk" if factor_dominance else "Specific Risk",+ "risk_concentration": "High" if max(factor_risk, specific_risk) / total_risk > 0.8 else "Moderate",+ "diversification_effectiveness": "Good" if min(factor_risk, specific_risk) / total_risk > 0.2 else "Poor"+ }++ if factor_dominance:+ analysis["implications"] = [+ "Portfolio risk driven by systematic factor exposures",+ "Consider factor hedging to reduce risk",+ "Factor timing may be significant component of returns"+ ]+ else:+ analysis["implications"] = [+ "Portfolio risk driven by security-specific factors",+ "Diversification may help reduce risk",+ "Stock selection appears to be primary focus"+ ]++ return analysis++ @staticmethod+ def _assess_tracking_risk_stability(rolling_tracking_risk: np.ndarray) -> Dict:+ """Assess stability of tracking risk over time"""++ coefficient_of_variation = np.std(rolling_tracking_risk) / np.mean(rolling_tracking_risk)++ if coefficient_of_variation < 0.2:+ stability = "High"+ assessment = "Tracking risk is very stable"+ elif coefficient_of_variation < 0.4:+ stability = "Moderate"+ assessment = "Tracking risk shows some variation"+ else:+ stability = "Low"+ assessment = "Tracking risk is highly variable"++ return {+ "stability_level": stability,+ "assessment": assessment,+ "coefficient_of_variation": coefficient_of_variation,+ "trend_analysis": "Increasing" if rolling_tracking_risk[-1] > rolling_tracking_risk[0] else "Decreasing"+ }++ @staticmethod+ def _analyze_active_returns(active_returns: np.ndarray) -> Dict:+ """Analyze active return characteristics"""++ return {+ "mean_active_return": np.mean(active_returns) * MathConstants.TRADING_DAYS_YEAR,+ "active_return_volatility": np.std(active_returns, ddof=1) * MathConstants.SQRT_TRADING_DAYS,+ "active_return_skewness": ActiveRiskTracking._calculate_skewness(active_returns),+ "hit_rate": np.sum(active_returns > 0) / len(active_returns),+ "up_capture": np.mean(active_returns[active_returns > 0]) if np.any(active_returns > 0) else 0,+ "down_capture": np.mean(active_returns[active_returns < 0]) if np.any(active_returns < 0) else 0+ }++ @staticmethod+ def _calculate_skewness(data: np.ndarray) -> float:+ """Calculate skewness of data"""+ mean = np.mean(data)+ std = np.std(data, ddof=1)+ n = len(data)++ if std == 0:+ return 0++ skewness = n / ((n - 1) * (n - 2)) * np.sum(((data - mean) / std) ** 3)+ return skewness+++class StrategyCombination:+ """Analysis of combining active management strategies"""++ @staticmethod+ def analyze_strategy_combination(strategy1_data: Dict, strategy2_data: Dict,+ correlation: float = 0.3) -> Dict:+ """Analyze combination of two active management strategies"""++ # Extract strategy metrics+ s1_return = strategy1_data.get("expected_return", 0.02)+ s1_risk = strategy1_data.get("tracking_error", 0.04)+ s1_ir = s1_return / s1_risk if s1_risk > 0 else 0++ s2_return = strategy2_data.get("expected_return", 0.015)+ s2_risk = strategy2_data.get("tracking_error", 0.03)+ s2_ir = s2_return / s2_risk if s2_risk > 0 else 0++ # Equal weight combination (can be optimized)+ weight1 = 0.5+ weight2 = 0.5++ # Combined portfolio metrics+ combined_return = weight1 * s1_return + weight2 * s2_return+ combined_variance = (weight1 * s1_risk) ** 2 + (+ weight2 * s2_risk) ** 2 + 2 * weight1 * weight2 * correlation * s1_risk * s2_risk+ combined_risk = np.sqrt(combined_variance)+ combined_ir = combined_return / combined_risk if combined_risk > 0 else 0++ # Optimal weights for maximum IR+ optimal_weights = StrategyCombination._calculate_optimal_weights(+ s1_return, s1_risk, s2_return, s2_risk, correlation+ )++ return {+ "individual_strategies": {+ "strategy1": {"return": s1_return, "risk": s1_risk, "ir": s1_ir},+ "strategy2": {"return": s2_return, "risk": s2_risk, "ir": s2_ir}+ },+ "equal_weight_combination": {+ "weights": [weight1, weight2],+ "expected_return": combined_return,+ "tracking_error": combined_risk,+ "information_ratio": combined_ir+ },+ "optimal_combination": optimal_weights,+ "correlation_impact": StrategyCombination._analyze_correlation_impact(+ s1_risk, s2_risk, correlation+ ),+ "diversification_benefit": StrategyCombination._calculate_diversification_benefit(+ s1_risk, s2_risk, combined_risk, weight1, weight2+ )+ }++ @staticmethod+ def _calculate_optimal_weights(return1: float, risk1: float, return2: float,+ risk2: float, correlation: float) -> Dict:+ """Calculate optimal weights for maximum Information Ratio"""++ # Covariance matrix+ cov_matrix = np.array([+ [risk1 ** 2, correlation * risk1 * risk2],+ [correlation * risk1 * risk2, risk2 ** 2]+ ])++ # Expected returns vector+ returns = np.array([return1, return2])++ # Calculate optimal weights (maximize IR = w'μ / sqrt(w'Σw))+ try:+ inv_cov = np.linalg.inv(cov_matrix)+ optimal_weights = np.dot(inv_cov, returns)+ optimal_weights = optimal_weights / np.sum(optimal_weights) # Normalize to sum to 1++ # Calculate optimal portfolio metrics+ opt_return = np.dot(optimal_weights, returns)+ opt_variance = np.dot(optimal_weights, np.dot(cov_matrix, optimal_weights))+ opt_risk = np.sqrt(opt_variance)+ opt_ir = opt_return / opt_risk if opt_risk > 0 else 0++ return {+ "optimal_weights": optimal_weights.tolist(),+ "optimal_return": opt_return,+ "optimal_risk": opt_risk,+ "optimal_ir": opt_ir,+ "improvement_vs_equal_weight": opt_ir - (opt_return / opt_risk if opt_risk > 0 else 0)+ }++ except np.linalg.LinAlgError:+ return {+ "optimal_weights": [0.5, 0.5],+ "note": "Singular covariance matrix - using equal weights"+ }++ @staticmethod+ def _analyze_correlation_impact(risk1: float, risk2: float, correlation: float) -> Dict:+ """Analyze impact of correlation on strategy combination"""++ # Risk reduction scenarios+ scenarios = {}+ for corr in [-0.5, 0.0, 0.5, 1.0]:+ combined_variance = 0.25 * risk1 ** 2 + 0.25 * risk2 ** 2 + 2 * 0.5 * 0.5 * corr * risk1 * risk2+ combined_risk = np.sqrt(combined_variance)+ scenarios[f"correlation_{corr}"] = combined_risk++ return {+ "correlation_scenarios": scenarios,+ "current_correlation": correlation,+ "risk_reduction_potential": scenarios["correlation_-0.5"] - scenarios["correlation_1.0"],+ "diversification_effectiveness": "High" if correlation < 0.3 else "Moderate" if correlation < 0.7 else "Low"+ }+++class ActiveManagement:+ """Main active portfolio management interface"""++ def __init__(self):+ self.value_measurement = ValueAddedMeasurement()+ self.ir_analysis = InformationRatioAnalysis()+ self.fundamental_law = FundamentalLawActiveManagement()+ self.multifactor_models = MultifactorModels()+ self.active_risk_tracking = ActiveRiskTracking()+ self.strategy_combination = StrategyCombination()++ def comprehensive_active_management_analysis(self, portfolio_data: Dict,+ benchmark_data: Dict,+ factor_data: Optional[Dict] = None) -> Dict:+ """Comprehensive active management analysis"""++ portfolio_returns = np.array(portfolio_data.get("returns", []))+ benchmark_returns = np.array(benchmark_data.get("returns", []))++ # Value added measurement+ value_added = self.value_measurement.calculate_value_added(+ portfolio_returns, benchmark_returns+ )++ # Information ratio analysis+ ir_analysis = self.ir_analysis.calculate_information_ratio_ex_post(+ portfolio_returns, benchmark_returns+ )++ # Fundamental law analysis+ if "fundamental_law_inputs" in portfolio_data:+ fl_analysis = self.fundamental_law.calculate_fundamental_law_components(+ portfolio_data["fundamental_law_inputs"]+ )+ else:+ fl_analysis = {"note": "Fundamental law inputs not provided"}++ # Risk decomposition if factor data available+ risk_analysis = {}+ if factor_data:+ portfolio_weights = np.array(portfolio_data.get("weights", []))+ benchmark_weights = np.array(benchmark_data.get("weights", []))++ if len(portfolio_weights) == len(benchmark_weights):+ risk_analysis = self.active_risk_tracking.decompose_active_risk(+ portfolio_weights,+ benchmark_weights,+ factor_data.get("factor_exposures", np.array([])),+ factor_data.get("factor_covariance", np.array([])),+ factor_data.get("specific_risk", np.array([]))+ )++ # Tracking risk analysis+ tracking_analysis = self.active_risk_tracking.calculate_tracking_risk(+ portfolio_returns, benchmark_returns+ )++ return {+ "value_added_analysis": value_added,+ "information_ratio_analysis": ir_analysis,+ "fundamental_law_analysis": fl_analysis,+ "risk_decomposition": risk_analysis,+ "tracking_risk_analysis": tracking_analysis,+ "active_management_assessment": self._assess_active_management_quality(+ value_added, ir_analysis, tracking_analysis+ ),+ "improvement_recommendations": self._generate_improvement_recommendations(+ value_added, ir_analysis, fl_analysis+ )+ }++ def manager_selection_analysis(self, manager_candidates: List[Dict]) -> Dict:+ """Analyze and compare active manager candidates"""++ manager_scores = {}++ for i, manager in enumerate(manager_candidates):+ manager_id = manager.get("manager_id", f"Manager_{i + 1}")++ # Calculate key metrics+ returns = np.array(manager.get("returns", []))+ benchmark_returns = np.array(manager.get("benchmark_returns", []))++ if len(returns) > 0 and len(benchmark_returns) > 0:+ ir_analysis = self.ir_analysis.calculate_information_ratio_ex_post(+ returns, benchmark_returns+ )++ # Manager scoring+ score = self._calculate_manager_score(ir_analysis, manager)++ manager_scores[manager_id] = {+ "information_ratio": ir_analysis["information_ratio_annualized"],+ "tracking_error": ir_analysis["tracking_error_annualized"],+ "active_return": ir_analysis["active_return_annualized"],+ "overall_score": score,+ "strengths": self._identify_manager_strengths(ir_analysis, manager),+ "concerns": self._identify_manager_concerns(ir_analysis, manager)+ }++ # Rank managers+ ranked_managers = sorted(manager_scores.items(),+ key=lambda x: x[1]["overall_score"], reverse=True)++ return {+ "manager_analysis": manager_scores,+ "manager_ranking": [manager[0] for manager in ranked_managers],+ "top_manager": ranked_managers[0][0] if ranked_managers else None,+ "selection_criteria": self._define_manager_selection_criteria(),+ "due_diligence_framework": self._manager_due_diligence_framework()+ }++ def factor_model_implementation(self, factor_data: Dict) -> Dict:+ """Implement and analyze factor model for active management"""++ # APT analysis+ apt_analysis = self.multifactor_models.arbitrage_pricing_theory_analysis()++ # Factor model comparison+ model_comparison = self.multifactor_models.compare_factor_models()++ # Multiple risk dimensions+ risk_benefits = self.multifactor_models.multiple_risk_dimensions_benefits()++ # Practical applications+ model_uses = self.multifactor_models.analyze_multifactor_model_uses(factor_data)++ return {+ "apt_framework": apt_analysis,+ "factor_model_comparison": model_comparison,+ "multiple_risk_dimensions": risk_benefits,+ "practical_applications": model_uses,+ "implementation_recommendations": self._factor_model_implementation_recommendations(+ factor_data+ )+ }++ def _assess_active_management_quality(self, value_added: Dict,+ ir_analysis: Dict, tracking_analysis: Dict) -> Dict:+ """Assess overall active management quality"""++ ir = ir_analysis.get("information_ratio_annualized", 0)+ active_return = value_added.get("active_return_annualized", 0)+ hit_rate = value_added.get("hit_rate", 0.5)++ # Quality scoring+ quality_score = 0++ # Information ratio component (40%)+ if ir > 0.5:+ quality_score += 40+ elif ir > 0.25:+ quality_score += 30+ elif ir > 0:+ quality_score += 20++ # Active return component (30%)+ if active_return > 0.02:+ quality_score += 30+ elif active_return > 0:+ quality_score += 20++ # Hit rate component (20%)+ if hit_rate > 0.6:+ quality_score += 20+ elif hit_rate > 0.5:+ quality_score += 15++ # Consistency component (10%)+ te_stability = tracking_analysis.get("tracking_risk_stability", {}).get("stability_level", "Low")+ if te_stability == "High":+ quality_score += 10+ elif te_stability == "Moderate":+ quality_score += 5++ return {+ "quality_score": quality_score,+ "quality_rating": "Excellent" if quality_score > 80 else+ "Good" if quality_score > 60 else+ "Average" if quality_score > 40 else "Poor",+ "key_strengths": self._identify_key_strengths(ir, active_return, hit_rate),+ "areas_for_improvement": self._identify_improvement_areas(ir, active_return, hit_rate)+ }++ def _generate_improvement_recommendations(self, value_added: Dict,+ ir_analysis: Dict, fl_analysis: Dict) -> List[str]:+ """Generate specific improvement recommendations"""++ recommendations = []++ ir = ir_analysis.get("information_ratio_annualized", 0)+ if ir < 0.25:+ recommendations.append("Focus on improving information ratio through better forecasting or risk control")++ hit_rate = value_added.get("hit_rate", 0.5)+ if hit_rate < 0.55:+ recommendations.append("Improve hit rate through better market timing or security selection")++ if "fundamental_law_inputs" in fl_analysis:+ fl_inputs = fl_analysis.get("fundamental_law_inputs", {})+ ic = fl_inputs.get("information_coefficient", 0)+ breadth = fl_inputs.get("breadth", 0)+ tc = fl_inputs.get("transfer_coefficient", 0)++ if ic < 0.05:+ recommendations.append("Enhance forecasting skill (information coefficient)")+ if breadth < 50:+ recommendations.append("Increase breadth of investment opportunities")+ if tc < 0.7:+ recommendations.append("Improve implementation efficiency (transfer coefficient)")++ if not recommendations:+ recommendations.append("Continue current strategy while monitoring for performance persistence")++ return recommendations++ def _calculate_manager_score(self, ir_analysis: Dict, manager_data: Dict) -> float:+ """Calculate overall manager score"""++ ir = ir_analysis.get("information_ratio_annualized", 0)+ track_record_length = manager_data.get("track_record_years", 3)+ assets_under_management = manager_data.get("aum_billions", 1)++ # Base score from IR (60%)+ base_score = min(100, max(0, ir * 100)) * 0.6++ # Track record adjustment (25%)+ track_record_score = min(25, track_record_length * 5)++ # AUM adjustment (15%) - preference for moderate size+ if 1 <= assets_under_management <= 10:+ aum_score = 15+ elif 0.5 <= assets_under_management <= 20:+ aum_score = 10+ else:+ aum_score = 5++ return base_score + track_record_score + aum_score++ def _identify_manager_strengths(self, ir_analysis: Dict, manager_data: Dict) -> List[str]:+ """Identify manager strengths"""++ strengths = []++ ir = ir_analysis.get("information_ratio_annualized", 0)+ if ir > 0.5:+ strengths.append("Excellent risk-adjusted performance")++ active_return = ir_analysis.get("active_return_annualized", 0)+ if active_return > 0.02:+ strengths.append("Strong active return generation")++ track_record = manager_data.get("track_record_years", 3)+ if track_record > 5:+ strengths.append("Long track record demonstrates consistency")++ return strengths++ def _factor_model_implementation_recommendations(self, factor_data: Dict) -> List[str]:+ """Provide factor model implementation recommendations"""++ recommendations = [+ "Start with fundamental factor model for intuitive factor interpretation",+ "Ensure factor data quality and regular updates",+ "Implement robust factor exposure monitoring",+ "Use factor models for risk budgeting and portfolio construction",+ "Regular model validation and performance testing",+ "Consider transaction costs in factor-based strategies"+ ]++ return recommendations++ # Helper methods for various analyses+ def _identify_key_strengths(self, ir: float, active_return: float, hit_rate: float) -> List[str]:+ """Identify key strengths of active management"""+ strengths = []++ if ir > 0.5:+ strengths.append("Excellent information ratio")+ if active_return > 0.015:+ strengths.append("Strong active return generation")+ if hit_rate > 0.6:+ strengths.append("High hit rate indicates good timing")++ return strengths++ def _identify_improvement_areas(self, ir: float, active_return: float, hit_rate: float) -> List[str]:+ """Identify areas for improvement"""+ areas = []++ if ir < 0.25:+ areas.append("Information ratio below industry average")+ if active_return < 0.005:+ areas.append("Limited active return generation")+ if hit_rate < 0.5:+ areas.append("Hit rate below 50% indicates poor timing")++ return areas++ def _define_manager_selection_criteria(self) -> Dict:+ """Define criteria for manager selection"""+ return {+ "quantitative_criteria": [+ "Information ratio > 0.5",+ "Track record > 3 years",+ "Consistent performance across periods",+ "Reasonable fees relative to value added"+ ],+ "qualitative_criteria": [+ "Clear investment philosophy",+ "Experienced investment team",+ "Robust risk management process",+ "Transparent reporting and communication"+ ],+ "risk_criteria": [+ "Appropriate risk controls",+ "Style consistency",+ "Capacity constraints awareness",+ "Business risk assessment"+ ]+ }++ def _manager_due_diligence_framework(self) -> Dict:+ """Comprehensive manager due diligence framework"""+ return {+ "investment_process": [+ "Investment philosophy and approach",+ "Research process and resources",+ "Portfolio construction methodology",+ "Risk management framework"+ ],+ "performance_analysis": [+ "Return attribution analysis",+ "Risk-adjusted performance metrics",+ "Performance consistency",+ "Benchmark relative analysis"+ ],+ "organizational_assessment": [+ "Team experience and stability",+ "Business ownership structure",+ "Operational infrastructure",+ "Compliance and risk controls"+ ],+ "ongoing_monitoring": [+ "Regular performance review",+ "Process consistency verification",+ "Key person risk monitoring",+ "Capacity utilization tracking"+ ]+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/behavioral_finance.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/behavioral_finance.pynew file mode 100644index 000000000..7e7b941d8--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/behavioral_finance.py@@ -0,0 +1,29 @@++Portfolio Behavioral Finance Module+===============================++Behavioral finance analysis and applications++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/config.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/config.pynew file mode 100644index 000000000..c30b15d52--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/config.py@@ -0,0 +1,266 @@++Portfolio Config Module+===============================++Portfolio management configuration++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++from dataclasses import dataclass+from typing import Dict, List, Optional, Tuple, Union+from enum import Enum+import numpy as np+++# Mathematical Constants+class MathConstants:+ """Mathematical constants used across analytics"""+ TRADING_DAYS_YEAR = 252+ BUSINESS_DAYS_YEAR = 252+ CALENDAR_DAYS_YEAR = 365+ SQRT_TRADING_DAYS = np.sqrt(TRADING_DAYS_YEAR)++ # Risk-free rate assumptions+ DEFAULT_RISK_FREE_RATE = 0.03 # 3% annual++ # Optimization parameters+ MAX_ITERATIONS = 10000+ CONVERGENCE_TOLERANCE = 1e-8++ # Statistical defaults+ CONFIDENCE_LEVELS = [0.90, 0.95, 0.99]+ DEFAULT_CONFIDENCE = 0.95+++# Asset Classes+class AssetClass(Enum):+ """Major asset classes for portfolio construction"""+ EQUITY = "equity"+ FIXED_INCOME = "fixed_income"+ COMMODITIES = "commodities"+ REAL_ESTATE = "real_estate"+ CASH = "cash"+ ALTERNATIVES = "alternatives"+ CRYPTO = "crypto"+++# Risk Metrics+class RiskMetric(Enum):+ """Risk measurement types"""+ STANDARD_DEVIATION = "standard_deviation"+ VARIANCE = "variance"+ VaR = "value_at_risk"+ CVaR = "conditional_value_at_risk"+ BETA = "beta"+ TRACKING_ERROR = "tracking_error"+ DOWNSIDE_DEVIATION = "downside_deviation"+++# Performance Metrics+class PerformanceMetric(Enum):+ """Performance measurement types"""+ SHARPE_RATIO = "sharpe_ratio"+ TREYNOR_RATIO = "treynor_ratio"+ INFORMATION_RATIO = "information_ratio"+ JENSEN_ALPHA = "jensen_alpha"+ M_SQUARED = "m_squared"+ SORTINO_RATIO = "sortino_ratio"+++# Data Validation Schemas+@dataclass+class DataSchema:+ """Data validation requirements"""+ required_columns: List[str]+ optional_columns: List[str]+ date_columns: List[str]+ numeric_columns: List[str]+ min_observations: int+ max_missing_ratio: float+++# Portfolio Analytics Parameters+@dataclass+class PortfolioParameters:+ """Portfolio analytics configuration"""+ min_weight: float = 0.0+ max_weight: float = 1.0+ weight_sum_tolerance: float = 1e-6+ return_frequency: str = "daily" # daily, weekly, monthly, annual+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE++ # Efficient frontier parameters+ num_frontier_points: int = 100+ min_return_percentile: float = 0.05+ max_return_percentile: float = 0.95+++# Risk Management Parameters+@dataclass+class RiskParameters:+ """Risk management configuration"""+ var_confidence_levels: List[float] = None+ var_holding_period: int = 1 # days+ monte_carlo_simulations: int = 10000+ historical_window: int = 252 # trading days++ # Stress testing+ stress_scenarios: Dict[str, float] = None++ def __post_init__(self):+ if self.var_confidence_levels is None:+ self.var_confidence_levels = [0.95, 0.99]+ if self.stress_scenarios is None:+ self.stress_scenarios = {+ "market_crash": -0.20,+ "mild_stress": -0.10,+ "extreme_stress": -0.30+ }+++# Data Provider Configuration+@dataclass+class DataProviderConfig:+ """Data provider settings"""+ provider_name: str+ api_key: Optional[str] = None+ base_url: Optional[str] = None+ rate_limit: int = 1000 # requests per hour+ timeout: int = 30 # seconds+ retry_attempts: int = 3+ cache_duration: int = 3600 # seconds+++# Behavioral Finance Parameters+@dataclass+class BehavioralParameters:+ """Behavioral finance configuration"""+ bias_types: List[str] = None+ risk_aversion_levels: Dict[str, float] = None+ utility_function_type: str = "power" # power, exponential, log++ def __post_init__(self):+ if self.bias_types is None:+ self.bias_types = [+ "overconfidence", "anchoring", "loss_aversion",+ "mental_accounting", "herding", "confirmation_bias"+ ]+ if self.risk_aversion_levels is None:+ self.risk_aversion_levels = {+ "low": 1.0,+ "moderate": 3.0,+ "high": 5.0,+ "very_high": 10.0+ }+++# Economics Analysis Parameters+@dataclass+class EconomicsParameters:+ """Economics and markets configuration"""+ business_cycle_indicators: List[str] = None+ yield_curve_maturities: List[int] = None # years+ credit_rating_categories: List[str] = None++ def __post_init__(self):+ if self.business_cycle_indicators is None:+ self.business_cycle_indicators = [+ "gdp_growth", "unemployment_rate", "inflation_rate",+ "yield_curve_slope", "credit_spreads", "equity_volatility"+ ]+ if self.yield_curve_maturities is None:+ self.yield_curve_maturities = [0.25, 0.5, 1, 2, 5, 10, 30]+ if self.credit_rating_categories is None:+ self.credit_rating_categories = [+ "AAA", "AA", "A", "BBB", "BB", "B", "CCC", "CC", "C", "D"+ ]+++# Default Configurations+DEFAULT_PORTFOLIO_PARAMS = PortfolioParameters()+DEFAULT_RISK_PARAMS = RiskParameters()+DEFAULT_BEHAVIORAL_PARAMS = BehavioralParameters()+DEFAULT_ECONOMICS_PARAMS = EconomicsParameters()++# Data Schemas+PRICE_DATA_SCHEMA = DataSchema(+ required_columns=["date", "close"],+ optional_columns=["open", "high", "low", "volume", "adjusted_close"],+ date_columns=["date"],+ numeric_columns=["open", "high", "low", "close", "volume", "adjusted_close"],+ min_observations=30,+ max_missing_ratio=0.05+)++RETURN_DATA_SCHEMA = DataSchema(+ required_columns=["date", "return"],+ optional_columns=["excess_return", "benchmark_return"],+ date_columns=["date"],+ numeric_columns=["return", "excess_return", "benchmark_return"],+ min_observations=30,+ max_missing_ratio=0.02+)++PORTFOLIO_DATA_SCHEMA = DataSchema(+ required_columns=["asset", "weight"],+ optional_columns=["expected_return", "volatility", "beta"],+ date_columns=[],+ numeric_columns=["weight", "expected_return", "volatility", "beta"],+ min_observations=2,+ max_missing_ratio=0.0+)++# Error Messages+ERROR_MESSAGES = {+ "insufficient_data": "Insufficient data points for analysis",+ "invalid_weights": "Portfolio weights must sum to 1.0",+ "negative_variance": "Negative variance detected in calculations",+ "singular_matrix": "Covariance matrix is singular",+ "optimization_failed": "Portfolio optimization failed to converge",+ "invalid_date_range": "Invalid date range specified",+ "missing_risk_free_rate": "Risk-free rate not specified",+ "invalid_confidence_level": "Confidence level must be between 0 and 1"+}+++# Validation Functions+def validate_weights(weights: Union[List, np.ndarray], tolerance: float = 1e-6) -> bool:+ """Validate portfolio weights sum to 1.0"""+ return abs(np.sum(weights) - 1.0) <= tolerance+++def validate_returns(returns: Union[List, np.ndarray]) -> bool:+ """Validate return data"""+ returns_array = np.array(returns)+ return not np.any(np.isnan(returns_array)) and len(returns_array) >= 2+++def validate_covariance_matrix(cov_matrix: np.ndarray) -> bool:+ """Validate covariance matrix properties"""+ if cov_matrix.shape[0] != cov_matrix.shape[1]:+ return False+ if not np.allclose(cov_matrix, cov_matrix.T):+ return False+ eigenvals = np.linalg.eigvals(cov_matrix)+ return np.all(eigenvals >= -1e-8) # Allow small numerical errors\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/data_manager.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/data_manager.pynew file mode 100644index 000000000..4fcecacac--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/data_manager.py@@ -0,0 +1,400 @@++Portfolio Data Manager Module+===============================++Portfolio data management and processing++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import pandas as pd+import numpy as np+from typing import Dict, List, Optional, Union, Tuple, Any+from datetime import datetime, timedelta+import warnings+from pathlib import Path+import json+import pickle+from abc import ABC, abstractmethod++from config import (+ DataSchema, AssetClass, MathConstants,+ PRICE_DATA_SCHEMA, RETURN_DATA_SCHEMA, PORTFOLIO_DATA_SCHEMA,+ ERROR_MESSAGES, validate_returns+)+++class DataProvider(ABC):+ """Abstract base class for data providers"""++ @abstractmethod+ def get_price_data(self, symbols: List[str], start_date: str, end_date: str) -> pd.DataFrame:+ pass++ @abstractmethod+ def get_economic_data(self, indicators: List[str], start_date: str, end_date: str) -> pd.DataFrame:+ pass+++class ManualDataProvider(DataProvider):+ """Manual data input provider"""++ def __init__(self):+ self.price_data = {}+ self.economic_data = {}++ def add_price_data(self, symbol: str, data: pd.DataFrame):+ """Add price data manually"""+ self.price_data[symbol] = data++ def add_economic_data(self, indicator: str, data: pd.DataFrame):+ """Add economic data manually"""+ self.economic_data[indicator] = data++ def get_price_data(self, symbols: List[str], start_date: str, end_date: str) -> pd.DataFrame:+ """Retrieve price data for symbols"""+ result_data = {}+ for symbol in symbols:+ if symbol in self.price_data:+ data = self.price_data[symbol].copy()+ data = self._filter_by_date(data, start_date, end_date)+ result_data[symbol] = data+ return result_data++ def get_economic_data(self, indicators: List[str], start_date: str, end_date: str) -> pd.DataFrame:+ """Retrieve economic data"""+ result_data = {}+ for indicator in indicators:+ if indicator in self.economic_data:+ data = self.economic_data[indicator].copy()+ data = self._filter_by_date(data, start_date, end_date)+ result_data[indicator] = data+ return result_data++ def _filter_by_date(self, data: pd.DataFrame, start_date: str, end_date: str) -> pd.DataFrame:+ """Filter data by date range"""+ if 'date' in data.columns:+ data['date'] = pd.to_datetime(data['date'])+ mask = (data['date'] >= start_date) & (data['date'] <= end_date)+ return data[mask]+ return data+++class DataValidator:+ """Data validation and quality checks"""++ @staticmethod+ def validate_schema(data: pd.DataFrame, schema: DataSchema) -> Tuple[bool, List[str]]:+ """Validate data against schema"""+ errors = []++ # Check required columns+ for col in schema.required_columns:+ if col not in data.columns:+ errors.append(f"Missing required column: {col}")++ # Check minimum observations+ if len(data) < schema.min_observations:+ errors.append(f"Insufficient data: {len(data)} < {schema.min_observations}")++ # Check missing data ratio+ for col in schema.numeric_columns:+ if col in data.columns:+ missing_ratio = data[col].isnull().sum() / len(data)+ if missing_ratio > schema.max_missing_ratio:+ errors.append(f"Too much missing data in {col}: {missing_ratio:.2%}")++ # Validate date columns+ for col in schema.date_columns:+ if col in data.columns:+ try:+ pd.to_datetime(data[col])+ except:+ errors.append(f"Invalid date format in column: {col}")++ return len(errors) == 0, errors++ @staticmethod+ def check_data_quality(data: pd.DataFrame) -> Dict[str, Any]:+ """Comprehensive data quality assessment"""+ quality_report = {+ "total_rows": len(data),+ "total_columns": len(data.columns),+ "missing_data": {},+ "duplicates": 0,+ "outliers": {},+ "data_types": {}+ }++ # Missing data analysis+ for col in data.columns:+ missing_count = data[col].isnull().sum()+ quality_report["missing_data"][col] = {+ "count": missing_count,+ "percentage": missing_count / len(data) * 100+ }++ # Duplicate rows+ quality_report["duplicates"] = data.duplicated().sum()++ # Outlier detection (for numeric columns)+ numeric_cols = data.select_dtypes(include=[np.number]).columns+ for col in numeric_cols:+ if not data[col].isnull().all():+ Q1 = data[col].quantile(0.25)+ Q3 = data[col].quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - 1.5 * IQR+ upper_bound = Q3 + 1.5 * IQR+ outliers = ((data[col] < lower_bound) | (data[col] > upper_bound)).sum()+ quality_report["outliers"][col] = outliers++ # Data types+ quality_report["data_types"] = dict(data.dtypes)++ return quality_report+++class DataTransformer:+ """Data cleaning and transformation utilities"""++ @staticmethod+ def calculate_returns(prices: pd.Series, method: str = "simple") -> pd.Series:+ """Calculate returns from price series"""+ if method == "simple":+ returns = prices.pct_change().dropna()+ elif method == "log":+ returns = np.log(prices / prices.shift(1)).dropna()+ else:+ raise ValueError("Method must be 'simple' or 'log'")++ return returns++ @staticmethod+ def handle_missing_data(data: pd.DataFrame, method: str = "forward_fill") -> pd.DataFrame:+ """Handle missing data"""+ data_clean = data.copy()++ if method == "forward_fill":+ data_clean = data_clean.fillna(method='ffill')+ elif method == "backward_fill":+ data_clean = data_clean.fillna(method='bfill')+ elif method == "interpolate":+ numeric_cols = data_clean.select_dtypes(include=[np.number]).columns+ data_clean[numeric_cols] = data_clean[numeric_cols].interpolate()+ elif method == "drop":+ data_clean = data_clean.dropna()+ elif method == "mean":+ numeric_cols = data_clean.select_dtypes(include=[np.number]).columns+ data_clean[numeric_cols] = data_clean[numeric_cols].fillna(data_clean[numeric_cols].mean())++ return data_clean++ @staticmethod+ def remove_outliers(data: pd.Series, method: str = "iqr", threshold: float = 1.5) -> pd.Series:+ """Remove outliers from data series"""+ if method == "iqr":+ Q1 = data.quantile(0.25)+ Q3 = data.quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - threshold * IQR+ upper_bound = Q3 + threshold * IQR+ return data[(data >= lower_bound) & (data <= upper_bound)]+ elif method == "zscore":+ z_scores = np.abs((data - data.mean()) / data.std())+ return data[z_scores <= threshold]++ return data++ @staticmethod+ def normalize_weights(weights: Union[List, np.ndarray]) -> np.ndarray:+ """Normalize weights to sum to 1.0"""+ weights_array = np.array(weights)+ return weights_array / np.sum(weights_array)++ @staticmethod+ def align_data(data_dict: Dict[str, pd.DataFrame], date_column: str = "date") -> Dict[str, pd.DataFrame]:+ """Align multiple datasets by common dates"""+ if not data_dict:+ return {}++ # Find common date range+ all_dates = None+ for key, df in data_dict.items():+ if date_column in df.columns:+ dates = pd.to_datetime(df[date_column])+ if all_dates is None:+ all_dates = set(dates)+ else:+ all_dates = all_dates.intersection(set(dates))++ if all_dates is None:+ return data_dict++ all_dates = sorted(list(all_dates))++ # Align all datasets+ aligned_data = {}+ for key, df in data_dict.items():+ if date_column in df.columns:+ df_copy = df.copy()+ df_copy[date_column] = pd.to_datetime(df_copy[date_column])+ aligned_data[key] = df_copy[df_copy[date_column].isin(all_dates)]+ else:+ aligned_data[key] = df++ return aligned_data+++class DataCache:+ """Simple file-based caching system"""++ def __init__(self, cache_dir: str = "cache"):+ self.cache_dir = Path(cache_dir)+ self.cache_dir.mkdir(exist_ok=True)++ def _get_cache_path(self, key: str) -> Path:+ """Generate cache file path"""+ return self.cache_dir / f"{key}.pkl"++ def get(self, key: str) -> Optional[Any]:+ """Retrieve data from cache"""+ cache_path = self._get_cache_path(key)+ if cache_path.exists():+ try:+ with open(cache_path, 'rb') as f:+ cached_data = pickle.load(f)++ # Check if cache is still valid (24 hours)+ cache_time = datetime.fromtimestamp(cache_path.stat().st_mtime)+ if datetime.now() - cache_time < timedelta(hours=24):+ return cached_data+ except:+ pass+ return None++ def set(self, key: str, data: Any) -> None:+ """Store data in cache"""+ cache_path = self._get_cache_path(key)+ try:+ with open(cache_path, 'wb') as f:+ pickle.dump(data, f)+ except Exception as e:+ warnings.warn(f"Failed to cache data: {e}")++ def clear(self) -> None:+ """Clear all cached data"""+ for cache_file in self.cache_dir.glob("*.pkl"):+ cache_file.unlink()+++class DataManager:+ """Main data management interface"""++ def __init__(self, provider: Optional[DataProvider] = None, use_cache: bool = True):+ self.provider = provider or ManualDataProvider()+ self.validator = DataValidator()+ self.transformer = DataTransformer()+ self.cache = DataCache() if use_cache else None++ def get_validated_data(self, data_type: str, **kwargs) -> Tuple[pd.DataFrame, Dict]:+ """Get and validate data"""+ cache_key = f"{data_type}_{hash(str(kwargs))}"++ # Try cache first+ if self.cache:+ cached_result = self.cache.get(cache_key)+ if cached_result is not None:+ return cached_result++ # Get data from provider+ if data_type == "price":+ raw_data = self.provider.get_price_data(**kwargs)+ schema = PRICE_DATA_SCHEMA+ elif data_type == "economic":+ raw_data = self.provider.get_economic_data(**kwargs)+ schema = None # Economic data schema varies+ else:+ raise ValueError(f"Unknown data type: {data_type}")++ # Process and validate data+ processed_data = {}+ validation_results = {}++ for key, df in raw_data.items():+ # Data quality check+ quality_report = self.validator.check_data_quality(df)++ # Schema validation if applicable+ if schema:+ is_valid, errors = self.validator.validate_schema(df, schema)+ validation_results[key] = {+ "valid": is_valid,+ "errors": errors,+ "quality": quality_report+ }++ # Clean data+ cleaned_df = self.transformer.handle_missing_data(df)+ processed_data[key] = cleaned_df++ result = (processed_data, validation_results)++ # Cache result+ if self.cache:+ self.cache.set(cache_key, result)++ return result++ def calculate_return_matrix(self, price_data: Dict[str, pd.DataFrame],+ return_type: str = "simple") -> pd.DataFrame:+ """Calculate return matrix from price data"""+ returns_dict = {}++ for symbol, df in price_data.items():+ if 'close' in df.columns and 'date' in df.columns:+ df_sorted = df.sort_values('date')+ prices = df_sorted['close']+ returns = self.transformer.calculate_returns(prices, return_type)+ returns_dict[symbol] = returns++ if not returns_dict:+ raise ValueError("No valid price data found")++ # Align returns by index+ return_matrix = pd.DataFrame(returns_dict)+ return return_matrix.dropna()++ def get_covariance_matrix(self, returns: pd.DataFrame,+ annualize: bool = True) -> np.ndarray:+ """Calculate covariance matrix from returns"""+ cov_matrix = returns.cov().values++ if annualize:+ cov_matrix *= MathConstants.TRADING_DAYS_YEAR++ return cov_matrix++ def get_correlation_matrix(self, returns: pd.DataFrame) -> np.ndarray:+ """Calculate correlation matrix from returns"""+ return returns.corr().values\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/economics_markets.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/economics_markets.pynew file mode 100644index 000000000..5973b00a4--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/economics_markets.py@@ -0,0 +1,746 @@++Portfolio Economics Markets Module+===============================++Economic analysis for portfolio management++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple+from enum import Enum++from config import MathConstants++class BusinessCyclePhase(Enum):+ EXPANSION = "expansion"+ PEAK = "peak"+ CONTRACTION = "contraction"+ TROUGH = "trough"++class MarketValuationFactors:+ """Economic factors affecting market values"""++ @staticmethod+ def analyze_valuation_drivers() -> Dict:+ """Analyze three key drivers of market valuation"""+ return {+ "default_free_rates": {+ "description": "Risk-free interest rates across maturities affect discount rates",+ "impact_mechanism": "Higher rates reduce present value of future cash flows",+ "yield_curve_importance": "Term structure affects valuation of different duration assets",+ "policy_influence": "Central bank policy directly impacts short-term rates"+ },+ "cash_flow_expectations": {+ "description": "Expected timing and magnitude of cash flows",+ "earnings_growth": "Corporate earnings growth drives equity valuations",+ "dividend_expectations": "Dividend growth affects equity value",+ "credit_quality": "Default expectations affect bond valuations"+ },+ "risk_premiums": {+ "description": "Additional return required for bearing risk",+ "equity_risk_premium": "Excess return demanded for equity over risk-free rate",+ "credit_spreads": "Additional yield for credit risk",+ "liquidity_premium": "Compensation for illiquidity"+ }+ }++ @staticmethod+ def expectations_impact_analysis() -> Dict:+ """Analyze role of expectations in market valuation"""+ return {+ "expectations_formation": {+ "rational_expectations": "Based on all available information",+ "adaptive_expectations": "Based on historical patterns",+ "behavioral_factors": "Psychological biases affect expectations"+ },+ "expectation_changes": {+ "surprise_announcements": "Unexpected news causes immediate price adjustments",+ "gradual_revision": "Slow information incorporation causes trend following",+ "regime_changes": "Structural changes require expectation resets"+ },+ "market_efficiency": {+ "efficient_market": "Prices reflect all available information",+ "semi_strong_form": "Public information quickly incorporated",+ "behavioral_deviations": "Systematic biases create opportunities"+ }+ }++class EconomicGrowthAnalysis:+ """Long-term growth and interest rate relationships"""++ @staticmethod+ def growth_volatility_rates_relationship() -> Dict:+ """Analyze relationship between growth, volatility, and real rates"""+ return {+ "theoretical_framework": {+ "growth_rate_impact": "Higher long-term growth supports higher real rates",+ "volatility_impact": "Higher growth volatility increases risk premiums",+ "equilibrium_relationship": "Real rates ≈ Long-term growth + risk premium"+ },+ "empirical_relationships": {+ "positive_growth_correlation": "Real rates tend to correlate with long-term growth",+ "volatility_premium": "Volatile economies typically have higher real rates",+ "international_comparison": "Developed economies show stronger correlation"+ },+ "policy_implications": {+ "central_bank_targeting": "Policy rates consider long-term growth potential",+ "fiscal_policy": "Government debt sustainability linked to growth",+ "investment_decisions": "Real rate environment affects capital allocation"+ }+ }++ @staticmethod+ def calculate_equilibrium_real_rate(long_term_growth: float,+ growth_volatility: float,+ risk_aversion: float = 2.0) -> Dict:+ """Calculate equilibrium real interest rate"""+ # Simplified model: r* = g + risk_premium+ growth_risk_premium = risk_aversion * (growth_volatility ** 2) / 2+ equilibrium_rate = long_term_growth + growth_risk_premium++ return {+ "equilibrium_real_rate": equilibrium_rate,+ "components": {+ "long_term_growth": long_term_growth,+ "growth_risk_premium": growth_risk_premium,+ "volatility_impact": growth_volatility+ },+ "sensitivity_analysis": {+ "growth_sensitivity": 1.0, # 1:1 relationship+ "volatility_sensitivity": risk_aversion * growth_volatility+ }+ }++class BusinessCycleAnalysis:+ """Business cycle effects on markets and policy"""++ CYCLE_CHARACTERISTICS = {+ BusinessCyclePhase.EXPANSION: {+ "gdp_growth": "positive_accelerating",+ "unemployment": "declining",+ "inflation": "rising",+ "policy_stance": "neutral_to_tightening",+ "yield_curve": "steepening_then_flattening"+ },+ BusinessCyclePhase.PEAK: {+ "gdp_growth": "positive_slowing",+ "unemployment": "low",+ "inflation": "high",+ "policy_stance": "restrictive",+ "yield_curve": "flat_or_inverted"+ },+ BusinessCyclePhase.CONTRACTION: {+ "gdp_growth": "negative",+ "unemployment": "rising",+ "inflation": "falling",+ "policy_stance": "accommodative",+ "yield_curve": "steepening"+ },+ BusinessCyclePhase.TROUGH: {+ "gdp_growth": "negative_to_positive",+ "unemployment": "high_but_stabilizing",+ "inflation": "low",+ "policy_stance": "very_accommodative",+ "yield_curve": "steep"+ }+ }++ @staticmethod+ def analyze_cycle_effects(current_phase: BusinessCyclePhase) -> Dict:+ """Analyze business cycle effects on policy and markets"""+ characteristics = BusinessCycleAnalysis.CYCLE_CHARACTERISTICS[current_phase]++ return {+ "current_phase": current_phase.value,+ "phase_characteristics": characteristics,+ "policy_implications": BusinessCycleAnalysis._policy_implications(current_phase),+ "market_implications": BusinessCycleAnalysis._market_implications(current_phase),+ "yield_curve_effects": BusinessCycleAnalysis._yield_curve_effects(current_phase)+ }++ @staticmethod+ def _policy_implications(phase: BusinessCyclePhase) -> Dict:+ """Policy implications by cycle phase"""+ policy_map = {+ BusinessCyclePhase.EXPANSION: {+ "monetary_policy": "Gradually tighten to prevent overheating",+ "fiscal_policy": "Reduce deficits, build fiscal space",+ "regulatory_stance": "May tighten financial regulations"+ },+ BusinessCyclePhase.PEAK: {+ "monetary_policy": "Restrictive to combat inflation",+ "fiscal_policy": "Counter-cyclical tightening",+ "regulatory_stance": "Monitor financial stability"+ },+ BusinessCyclePhase.CONTRACTION: {+ "monetary_policy": "Aggressive easing to support economy",+ "fiscal_policy": "Stimulus spending to cushion recession",+ "regulatory_stance": "May ease to support lending"+ },+ BusinessCyclePhase.TROUGH: {+ "monetary_policy": "Maintain accommodation for recovery",+ "fiscal_policy": "Continue support but plan exit strategy",+ "regulatory_stance": "Gradual normalization"+ }+ }+ return policy_map[phase]++ @staticmethod+ def _market_implications(phase: BusinessCyclePhase) -> Dict:+ """Market implications by cycle phase"""+ market_map = {+ BusinessCyclePhase.EXPANSION: {+ "equity_performance": "Strong performance, cyclicals outperform",+ "bond_performance": "Rising yields hurt bond performance",+ "credit_spreads": "Tightening spreads",+ "sector_rotation": "Financials, industrials, materials favor"+ },+ BusinessCyclePhase.PEAK: {+ "equity_performance": "Volatile, defensive sectors outperform",+ "bond_performance": "Poor performance due to high yields",+ "credit_spreads": "Beginning to widen",+ "sector_rotation": "Utilities, consumer staples favor"+ },+ BusinessCyclePhase.CONTRACTION: {+ "equity_performance": "Poor performance, high volatility",+ "bond_performance": "Strong performance as yields fall",+ "credit_spreads": "Widening significantly",+ "sector_rotation": "Quality defensive names outperform"+ },+ BusinessCyclePhase.TROUGH: {+ "equity_performance": "Recovery begins, cyclicals lead",+ "bond_performance": "Moderate as yields stabilize",+ "credit_spreads": "Peak widening, beginning to stabilize",+ "sector_rotation": "Early cyclicals, technology, discretionary"+ }+ }+ return market_map[phase]++ @staticmethod+ def _yield_curve_effects(phase: BusinessCyclePhase) -> Dict:+ """Yield curve effects by cycle phase"""+ curve_map = {+ BusinessCyclePhase.EXPANSION: {+ "curve_shape": "Steepening early, flattening late",+ "short_rates": "Rising gradually",+ "long_rates": "Rising but less than short rates",+ "duration_performance": "Negative for longer durations"+ },+ BusinessCyclePhase.PEAK: {+ "curve_shape": "Flat or inverted",+ "short_rates": "Peak levels",+ "long_rates": "Lower than short rates",+ "duration_performance": "Poor across all durations"+ },+ BusinessCyclePhase.CONTRACTION: {+ "curve_shape": "Steepening dramatically",+ "short_rates": "Falling rapidly",+ "long_rates": "Falling but less than short rates",+ "duration_performance": "Positive, especially long duration"+ },+ BusinessCyclePhase.TROUGH: {+ "curve_shape": "Steep",+ "short_rates": "Near zero",+ "long_rates": "Low but above short rates",+ "duration_performance": "Positive but moderating"+ }+ }+ return curve_map[phase]++class InflationAnalysis:+ """Inflation and bond market analysis"""++ @staticmethod+ def yield_spread_analysis() -> Dict:+ """Analyze factors affecting yield spreads"""+ return {+ "inflation_expectations": {+ "tips_vs_nominal": "TIPS spread indicates inflation expectations",+ "breakeven_inflation": "Market-implied inflation expectations",+ "survey_measures": "Professional forecaster expectations"+ },+ "liquidity_factors": {+ "tips_liquidity": "TIPS markets less liquid than nominal bonds",+ "seasonal_patterns": "Tax timing affects TIPS demand",+ "market_depth": "Smaller TIPS market affects pricing"+ },+ "technical_factors": {+ "supply_considerations": "TIPS issuance patterns",+ "demand_patterns": "Institutional demand for inflation protection",+ "relative_value": "TIPS vs nominal bond valuations"+ }+ }++ @staticmethod+ def calculate_breakeven_inflation(nominal_yield: float, tips_yield: float) -> Dict:+ """Calculate breakeven inflation rate"""+ breakeven_rate = nominal_yield - tips_yield++ return {+ "breakeven_inflation": breakeven_rate,+ "components": {+ "nominal_yield": nominal_yield,+ "tips_yield": tips_yield+ },+ "interpretation": {+ "market_expectation": f"Market expects {breakeven_rate:.2%} average inflation",+ "relative_value": "TIPS attractive if actual inflation exceeds breakeven" if breakeven_rate > 0.02 else "Nominal bonds may be preferred"+ }+ }++class CreditAnalysis:+ """Credit spreads and business cycle relationship"""++ @staticmethod+ def credit_cycle_analysis(cycle_phase: BusinessCyclePhase) -> Dict:+ """Analyze credit performance by business cycle phase"""+ credit_characteristics = {+ BusinessCyclePhase.EXPANSION: {+ "credit_spreads": "Tightening",+ "default_rates": "Declining",+ "credit_quality": "Improving",+ "issuance_activity": "High, deteriorating quality toward end"+ },+ BusinessCyclePhase.PEAK: {+ "credit_spreads": "Tight but beginning to widen",+ "default_rates": "Low but rising",+ "credit_quality": "Peak quality, starting to deteriorate",+ "issuance_activity": "High volume, lower quality"+ },+ BusinessCyclePhase.CONTRACTION: {+ "credit_spreads": "Widening significantly",+ "default_rates": "Rising sharply",+ "credit_quality": "Deteriorating rapidly",+ "issuance_activity": "Limited to high-quality issuers"+ },+ BusinessCyclePhase.TROUGH: {+ "credit_spreads": "Wide but stabilizing",+ "default_rates": "Peak levels",+ "credit_quality": "Stabilizing at low levels",+ "issuance_activity": "Low volume, high quality"+ }+ }++ return {+ "cycle_phase": cycle_phase.value,+ "credit_characteristics": credit_characteristics[cycle_phase],+ "investment_strategy": CreditAnalysis._credit_strategy(cycle_phase),+ "sector_considerations": CreditAnalysis._sector_credit_analysis(cycle_phase)+ }++ @staticmethod+ def _credit_strategy(phase: BusinessCyclePhase) -> Dict:+ """Credit investment strategy by phase"""+ strategy_map = {+ BusinessCyclePhase.EXPANSION: {+ "duration_strategy": "Shorter duration as rates rise",+ "credit_quality": "Can take more credit risk",+ "sector_allocation": "Cyclical sectors benefit"+ },+ BusinessCyclePhase.PEAK: {+ "duration_strategy": "Neutral duration",+ "credit_quality": "Begin moving to higher quality",+ "sector_allocation": "Reduce cyclical exposure"+ },+ BusinessCyclePhase.CONTRACTION: {+ "duration_strategy": "Longer duration benefits from falling rates",+ "credit_quality": "Focus on highest quality",+ "sector_allocation": "Defensive sectors only"+ },+ BusinessCyclePhase.TROUGH: {+ "duration_strategy": "Long duration still beneficial",+ "credit_quality": "Begin adding credit risk selectively",+ "sector_allocation": "Early cyclical opportunities"+ }+ }+ return strategy_map[phase]++ @staticmethod+ def _sector_credit_analysis(phase: BusinessCyclePhase) -> Dict:+ """Sector-specific credit analysis"""+ return {+ "cyclical_sectors": {+ "performance": "Strong in expansion, weak in contraction",+ "examples": ["Manufacturing", "Construction", "Retail"],+ "credit_characteristics": "Credit quality correlates with cycle"+ },+ "defensive_sectors": {+ "performance": "Stable across cycle",+ "examples": ["Utilities", "Healthcare", "Consumer staples"],+ "credit_characteristics": "More stable credit metrics"+ },+ "financial_sector": {+ "performance": "Benefits from steepening curve, hurt by credit losses",+ "credit_characteristics": "Sensitive to credit cycle and regulations",+ "special_considerations": "Regulatory capital requirements"+ }+ }++class EquityRiskPremium:+ """Equity risk premium and consumption hedging analysis"""++ @staticmethod+ def consumption_hedging_analysis() -> Dict:+ """Analyze equity risk premium through consumption hedging lens"""+ return {+ "theoretical_framework": {+ "consumption_capm": "Risk premium based on consumption risk",+ "hedging_properties": "Assets that hedge consumption risk command lower returns",+ "pro_cyclical_assets": "Assets correlated with consumption require higher returns"+ },+ "equity_characteristics": {+ "consumption_correlation": "Equities generally pro-cyclical with consumption",+ "recession_performance": "Poor performance when consumption falls",+ "required_premium": "Higher premium for poor consumption hedging"+ },+ "bond_characteristics": {+ "consumption_hedge": "Bonds often provide consumption hedging",+ "flight_to_quality": "Bonds rally when consumption threatened",+ "lower_premium": "Lower risk premium due to hedging properties"+ }+ }++ @staticmethod+ def estimate_equity_risk_premium(equity_volatility: float,+ consumption_volatility: float,+ correlation: float,+ risk_aversion: float = 3.0) -> Dict:+ """Estimate equity risk premium using consumption CAPM"""+ # Simplified consumption CAPM: ERP = γ * σ_c * σ_e * ρ+ risk_premium = risk_aversion * consumption_volatility * equity_volatility * correlation++ return {+ "estimated_risk_premium": risk_premium,+ "components": {+ "risk_aversion": risk_aversion,+ "consumption_volatility": consumption_volatility,+ "equity_volatility": equity_volatility,+ "correlation": correlation+ },+ "interpretation": {+ "premium_level": "High" if risk_premium > 0.06 else "Moderate" if risk_premium > 0.04 else "Low",+ "hedging_value": "Poor consumption hedge" if correlation > 0.5 else "Moderate hedge" if correlation > 0 else "Good hedge"+ }+ }++class EarningsAnalysis:+ """Earnings growth expectations and business cycle"""++ @staticmethod+ def earnings_cycle_analysis(cycle_phase: BusinessCyclePhase) -> Dict:+ """Analyze earnings expectations by cycle phase"""+ earnings_map = {+ BusinessCyclePhase.EXPANSION: {+ "short_term_growth": "Strong and accelerating",+ "long_term_growth": "Optimistic revisions upward",+ "earnings_quality": "Improving margins and volumes",+ "analyst_behavior": "Positive revisions, raising estimates"+ },+ BusinessCyclePhase.PEAK: {+ "short_term_growth": "Strong but decelerating",+ "long_term_growth": "Peak optimism, beginning to moderate",+ "earnings_quality": "Margins under pressure",+ "analyst_behavior": "Mixed revisions, uncertainty increasing"+ },+ BusinessCyclePhase.CONTRACTION: {+ "short_term_growth": "Negative and deteriorating",+ "long_term_growth": "Pessimistic, significant downgrades",+ "earnings_quality": "Weak across all metrics",+ "analyst_behavior": "Negative revisions, lowering estimates"+ },+ BusinessCyclePhase.TROUGH: {+ "short_term_growth": "Negative but stabilizing",+ "long_term_growth": "Beginning to look ahead to recovery",+ "earnings_quality": "Stabilizing at low levels",+ "analyst_behavior": "Stabilizing estimates, early optimism"+ }+ }++ return {+ "cycle_phase": cycle_phase.value,+ "earnings_characteristics": earnings_map[cycle_phase],+ "valuation_implications": EarningsAnalysis._valuation_implications(cycle_phase)+ }++ @staticmethod+ def _valuation_implications(phase: BusinessCyclePhase) -> Dict:+ """Valuation implications of earnings cycle"""+ valuation_map = {+ BusinessCyclePhase.EXPANSION: {+ "pe_multiples": "Expanding as growth accelerates",+ "forward_vs_trailing": "Forward PE below trailing as growth expected",+ "sector_dispersion": "Cyclicals commanding premium multiples"+ },+ BusinessCyclePhase.PEAK: {+ "pe_multiples": "Peak multiples but vulnerable",+ "forward_vs_trailing": "Forward PE rising as growth slows",+ "sector_dispersion": "Defensive sectors gaining multiple premium"+ },+ BusinessCyclePhase.CONTRACTION: {+ "pe_multiples": "Contracting significantly",+ "forward_vs_trailing": "Trailing PE very high due to depressed earnings",+ "sector_dispersion": "Quality and defensive at premium"+ },+ BusinessCyclePhase.TROUGH: {+ "pe_multiples": "Beginning to expand on recovery hopes",+ "forward_vs_trailing": "Forward PE much lower than trailing",+ "sector_dispersion": "Early cyclicals beginning to rerate"+ }+ }+ return valuation_map[phase]++class ValuationMultiples:+ """Cyclical effects on valuation multiples"""++ @staticmethod+ def multiple_analysis() -> Dict:+ """Analyze cyclical effects on valuation multiples"""+ return {+ "pe_ratio_cycles": {+ "expansion": "Rising P/E as growth expectations improve",+ "peak": "Peak P/E but vulnerable to disappointment",+ "contraction": "Falling P/E as earnings decline",+ "trough": "Low P/E but earnings depressed"+ },+ "ev_ebitda_cycles": {+ "advantages": "Less affected by depreciation and financial structure",+ "cycle_behavior": "Similar pattern to P/E but less volatile",+ "sector_utility": "Particularly useful for capital-intensive sectors"+ },+ "price_to_book": {+ "cycle_stability": "More stable through cycles",+ "financial_sectors": "Key metric for banks and insurers",+ "asset_quality": "Reflects asset quality and franchise value"+ }+ }++ @staticmethod+ def calculate_normalized_multiples(current_earnings: float,+ normalized_earnings: float,+ current_price: float) -> Dict:+ """Calculate normalized valuation multiples"""+ current_pe = current_price / current_earnings if current_earnings > 0 else float('inf')+ normalized_pe = current_price / normalized_earnings if normalized_earnings > 0 else float('inf')++ return {+ "current_pe": current_pe,+ "normalized_pe": normalized_pe,+ "valuation_assessment": {+ "current_basis": "Expensive" if current_pe > 20 else "Fair" if current_pe > 15 else "Cheap",+ "normalized_basis": "Expensive" if normalized_pe > 18 else "Fair" if normalized_pe > 12 else "Cheap"+ },+ "cycle_adjustment": normalized_pe - current_pe+ }++class RealEstateAnalysis:+ """Commercial real estate economic factors"""++ @staticmethod+ def real_estate_economic_factors() -> Dict:+ """Analyze economic factors affecting commercial real estate"""+ return {+ "demand_factors": {+ "economic_growth": "GDP growth drives space demand",+ "employment_growth": "Job creation increases office/retail demand",+ "population_growth": "Demographics drive residential demand",+ "business_formation": "New businesses need commercial space"+ },+ "supply_factors": {+ "construction_costs": "Material and labor costs affect new supply",+ "land_availability": "Zoning and development restrictions",+ "permitting_process": "Regulatory approval timelines",+ "developer_financing": "Credit availability for development"+ },+ "financial_factors": {+ "interest_rates": "Affect both cap rates and financing costs",+ "credit_availability": "Lending standards impact transactions",+ "equity_markets": "REIT performance affects capital flows",+ "inflation": "Affects both costs and rents"+ }+ }++ @staticmethod+ def real_estate_cycle_analysis(cycle_phase: BusinessCyclePhase) -> Dict:+ """Analyze real estate performance by economic cycle"""+ re_characteristics = {+ BusinessCyclePhase.EXPANSION: {+ "occupancy_rates": "Rising",+ "rent_growth": "Accelerating",+ "cap_rates": "Declining (rising values)",+ "development_activity": "Increasing"+ },+ BusinessCyclePhase.PEAK: {+ "occupancy_rates": "Peak levels",+ "rent_growth": "Strong but moderating",+ "cap_rates": "Low",+ "development_activity": "Peak levels, potential overbuilding"+ },+ BusinessCyclePhase.CONTRACTION: {+ "occupancy_rates": "Declining",+ "rent_growth": "Negative",+ "cap_rates": "Rising (falling values)",+ "development_activity": "Declining sharply"+ },+ BusinessCyclePhase.TROUGH: {+ "occupancy_rates": "Low but stabilizing",+ "rent_growth": "Flat to slightly negative",+ "cap_rates": "High but stabilizing",+ "development_activity": "Minimal"+ }+ }++ return {+ "cycle_phase": cycle_phase.value,+ "re_characteristics": re_characteristics[cycle_phase],+ "investment_strategy": RealEstateAnalysis._re_investment_strategy(cycle_phase)+ }++ @staticmethod+ def _re_investment_strategy(phase: BusinessCyclePhase) -> Dict:+ """Real estate investment strategy by cycle phase"""+ strategy_map = {+ BusinessCyclePhase.EXPANSION: {+ "property_types": "Core and value-add opportunities",+ "geographic_focus": "High-growth markets",+ "leverage_strategy": "Moderate leverage appropriate",+ "timing": "Good time to sell mature assets"+ },+ BusinessCyclePhase.PEAK: {+ "property_types": "Focus on core, stable properties",+ "geographic_focus": "Defensive markets",+ "leverage_strategy": "Reduce leverage exposure",+ "timing": "Opportune time to sell"+ },+ BusinessCyclePhase.CONTRACTION: {+ "property_types": "Avoid development, focus on income",+ "geographic_focus": "Defensive, diversified markets",+ "leverage_strategy": "Low leverage, preserve liquidity",+ "timing": "Hold existing, avoid new investments"+ },+ BusinessCyclePhase.TROUGH: {+ "property_types": "Opportunistic investments available",+ "geographic_focus": "Recovery markets",+ "leverage_strategy": "Conservative leverage for opportunities",+ "timing": "Excellent buying opportunities"+ }+ }+ return strategy_map[phase]++class EconomicsMarkets:+ """Main economics and markets interface"""++ def __init__(self):+ self.valuation_factors = MarketValuationFactors()+ self.growth_analysis = EconomicGrowthAnalysis()+ self.cycle_analysis = BusinessCycleAnalysis()+ self.inflation_analysis = InflationAnalysis()+ self.credit_analysis = CreditAnalysis()+ self.equity_premium = EquityRiskPremium()+ self.earnings_analysis = EarningsAnalysis()+ self.multiples_analysis = ValuationMultiples()+ self.real_estate = RealEstateAnalysis()++ def comprehensive_economics_analysis(self, current_cycle_phase: BusinessCyclePhase,+ economic_data: Dict) -> Dict:+ """Comprehensive economics and markets analysis"""++ # Business cycle analysis+ cycle_effects = self.cycle_analysis.analyze_cycle_effects(current_cycle_phase)++ # Credit analysis+ credit_analysis = self.credit_analysis.credit_cycle_analysis(current_cycle_phase)++ # Earnings analysis+ earnings_analysis = self.earnings_analysis.earnings_cycle_analysis(current_cycle_phase)++ # Real estate analysis+ re_analysis = self.real_estate.real_estate_cycle_analysis(current_cycle_phase)++ # Valuation factors+ valuation_drivers = self.valuation_factors.analyze_valuation_drivers()+ expectations_analysis = self.valuation_factors.expectations_impact_analysis()++ return {+ "current_cycle_phase": current_cycle_phase.value,+ "business_cycle_analysis": cycle_effects,+ "credit_market_analysis": credit_analysis,+ "earnings_expectations": earnings_analysis,+ "real_estate_analysis": re_analysis,+ "valuation_framework": {+ "valuation_drivers": valuation_drivers,+ "expectations_role": expectations_analysis+ },+ "investment_implications": self._synthesize_investment_implications(+ current_cycle_phase, cycle_effects, credit_analysis, earnings_analysis+ )+ }++ def _synthesize_investment_implications(self, phase: BusinessCyclePhase,+ cycle_effects: Dict,+ credit_analysis: Dict,+ earnings_analysis: Dict) -> Dict:+ """Synthesize investment implications across all analyses"""+ return {+ "asset_allocation_guidance": {+ "equity_allocation": self._equity_allocation_guidance(phase),+ "fixed_income_allocation": self._fixed_income_guidance(phase),+ "alternative_investments": self._alternatives_guidance(phase)+ },+ "sector_rotation": cycle_effects["market_implications"]["sector_rotation"],+ "duration_strategy": credit_analysis["investment_strategy"]["duration_strategy"],+ "credit_quality_preference": credit_analysis["investment_strategy"]["credit_quality"],+ "valuation_approach": earnings_analysis["valuation_implications"]+ }++ def _equity_allocation_guidance(self, phase: BusinessCyclePhase) -> str:+ """Equity allocation guidance by cycle phase"""+ guidance_map = {+ BusinessCyclePhase.EXPANSION: "Overweight equities, favor cyclicals",+ BusinessCyclePhase.PEAK: "Neutral to underweight, shift to defensives",+ BusinessCyclePhase.CONTRACTION: "Underweight equities, quality focus",+ BusinessCyclePhase.TROUGH: "Begin overweighting, early cyclical exposure"+ }+ return guidance_map[phase]++ def _fixed_income_guidance(self, phase: BusinessCyclePhase) -> str:+ """Fixed income guidance by cycle phase"""+ guidance_map = {+ BusinessCyclePhase.EXPANSION: "Shorter duration, higher quality",+ BusinessCyclePhase.PEAK: "Neutral duration, reduce credit risk",+ BusinessCyclePhase.CONTRACTION: "Longer duration, highest quality only",+ BusinessCyclePhase.TROUGH: "Long duration, selective credit opportunities"+ }+ return guidance_map[phase]++ def _alternatives_guidance(self, phase: BusinessCyclePhase) -> str:+ """Alternative investments guidance by cycle phase"""+ guidance_map = {+ BusinessCyclePhase.EXPANSION: "Real estate and commodities attractive",+ BusinessCyclePhase.PEAK: "Reduce cyclical alternatives exposure",+ BusinessCyclePhase.CONTRACTION: "Defensive alternatives, opportunistic funds",+ BusinessCyclePhase.TROUGH: "Distressed opportunities, value investing"+ }+ return guidance_map[phase]\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/etf_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/etf_analytics.pynew file mode 100644index 000000000..5bb140e81--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/etf_analytics.py@@ -0,0 +1,29 @@++Portfolio Etf Analytics Module+===============================++ETF analysis and selection tools++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/math_engine.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/math_engine.pynew file mode 100644index 000000000..ec05adfd4--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/math_engine.py@@ -0,0 +1,499 @@++Portfolio Math Engine Module+===============================++Mathematical engine for portfolio calculations++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple, Callable+from scipy import optimize, stats+from scipy.linalg import sqrtm, inv, LinAlgError+import warnings++from config import (+ MathConstants, PerformanceMetric, RiskMetric,+ validate_weights, validate_returns, validate_covariance_matrix,+ ERROR_MESSAGES+)+++class StatisticalCalculations:+ """Core statistical calculations for financial analysis"""++ @staticmethod+ def calculate_mean(data: Union[np.ndarray, pd.Series]) -> float:+ """Calculate arithmetic mean"""+ return np.mean(data)++ @staticmethod+ def calculate_variance(data: Union[np.ndarray, pd.Series], ddof: int = 1) -> float:+ """Calculate variance with degrees of freedom correction"""+ return np.var(data, ddof=ddof)++ @staticmethod+ def calculate_std(data: Union[np.ndarray, pd.Series], ddof: int = 1) -> float:+ """Calculate standard deviation"""+ return np.std(data, ddof=ddof)++ @staticmethod+ def calculate_covariance(x: Union[np.ndarray, pd.Series],+ y: Union[np.ndarray, pd.Series], ddof: int = 1) -> float:+ """Calculate covariance between two series"""+ return np.cov(x, y, ddof=ddof)[0, 1]++ @staticmethod+ def calculate_correlation(x: Union[np.ndarray, pd.Series],+ y: Union[np.ndarray, pd.Series]) -> float:+ """Calculate correlation coefficient"""+ return np.corrcoef(x, y)[0, 1]++ @staticmethod+ def calculate_beta(asset_returns: Union[np.ndarray, pd.Series],+ market_returns: Union[np.ndarray, pd.Series]) -> float:+ """Calculate beta coefficient"""+ covariance = StatisticalCalculations.calculate_covariance(asset_returns, market_returns)+ market_variance = StatisticalCalculations.calculate_variance(market_returns)+ return covariance / market_variance++ @staticmethod+ def calculate_tracking_error(portfolio_returns: Union[np.ndarray, pd.Series],+ benchmark_returns: Union[np.ndarray, pd.Series],+ annualize: bool = True) -> float:+ """Calculate tracking error"""+ excess_returns = np.array(portfolio_returns) - np.array(benchmark_returns)+ tracking_error = np.std(excess_returns, ddof=1)++ if annualize:+ tracking_error *= MathConstants.SQRT_TRADING_DAYS++ return tracking_error++ @staticmethod+ def calculate_downside_deviation(returns: Union[np.ndarray, pd.Series],+ target_return: float = 0.0,+ annualize: bool = True) -> float:+ """Calculate downside deviation"""+ returns_array = np.array(returns)+ downside_returns = returns_array[returns_array < target_return]++ if len(downside_returns) == 0:+ return 0.0++ downside_dev = np.sqrt(np.mean((downside_returns - target_return) ** 2))++ if annualize:+ downside_dev *= MathConstants.SQRT_TRADING_DAYS++ return downside_dev+++class PortfolioMath:+ """Portfolio mathematics and optimization"""++ @staticmethod+ def calculate_portfolio_return(weights: np.ndarray, expected_returns: np.ndarray) -> float:+ """Calculate expected portfolio return"""+ if not validate_weights(weights):+ raise ValueError(ERROR_MESSAGES["invalid_weights"])+ return np.dot(weights, expected_returns)++ @staticmethod+ def calculate_portfolio_variance(weights: np.ndarray, cov_matrix: np.ndarray) -> float:+ """Calculate portfolio variance"""+ if not validate_weights(weights):+ raise ValueError(ERROR_MESSAGES["invalid_weights"])+ if not validate_covariance_matrix(cov_matrix):+ raise ValueError(ERROR_MESSAGES["singular_matrix"])++ variance = np.dot(weights.T, np.dot(cov_matrix, weights))+ if variance < 0:+ raise ValueError(ERROR_MESSAGES["negative_variance"])+ return variance++ @staticmethod+ def calculate_portfolio_std(weights: np.ndarray, cov_matrix: np.ndarray) -> float:+ """Calculate portfolio standard deviation"""+ variance = PortfolioMath.calculate_portfolio_variance(weights, cov_matrix)+ return np.sqrt(variance)++ @staticmethod+ def calculate_diversification_ratio(weights: np.ndarray,+ individual_stds: np.ndarray,+ portfolio_std: float) -> float:+ """Calculate diversification ratio"""+ weighted_avg_std = np.dot(weights, individual_stds)+ return weighted_avg_std / portfolio_std++ @staticmethod+ def find_minimum_variance_portfolio(cov_matrix: np.ndarray,+ constraints: Optional[Dict] = None) -> Dict:+ """Find global minimum variance portfolio"""+ n = cov_matrix.shape[0]++ # Objective function: minimize portfolio variance+ def objective(weights):+ return PortfolioMath.calculate_portfolio_variance(weights, cov_matrix)++ # Constraints+ cons = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0}] # weights sum to 1++ if constraints:+ if 'min_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: w - constraints['min_weight']})+ if 'max_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: constraints['max_weight'] - w})++ # Bounds+ bounds = tuple((0, 1) for _ in range(n))++ # Initial guess+ x0 = np.ones(n) / n++ # Optimize+ result = optimize.minimize(objective, x0, method='SLSQP',+ bounds=bounds, constraints=cons,+ options={'maxiter': MathConstants.MAX_ITERATIONS})++ if not result.success:+ raise ValueError(ERROR_MESSAGES["optimization_failed"])++ optimal_weights = result.x+ min_variance = result.fun+ min_std = np.sqrt(min_variance)++ return {+ 'weights': optimal_weights,+ 'variance': min_variance,+ 'std': min_std,+ 'optimization_result': result+ }+++class PerformanceCalculations:+ """Performance and risk-adjusted return calculations"""++ @staticmethod+ def sharpe_ratio(returns: Union[np.ndarray, pd.Series],+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ annualize: bool = True) -> float:+ """Calculate Sharpe ratio"""+ if not validate_returns(returns):+ raise ValueError(ERROR_MESSAGES["insufficient_data"])++ returns_array = np.array(returns)+ excess_returns = returns_array - risk_free_rate / MathConstants.TRADING_DAYS_YEAR++ mean_excess = np.mean(excess_returns)+ std_excess = np.std(excess_returns, ddof=1)++ if std_excess == 0:+ return 0.0++ sharpe = mean_excess / std_excess++ if annualize:+ sharpe *= MathConstants.SQRT_TRADING_DAYS++ return sharpe++ @staticmethod+ def treynor_ratio(returns: Union[np.ndarray, pd.Series],+ beta: float,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ annualize: bool = True) -> float:+ """Calculate Treynor ratio"""+ if not validate_returns(returns):+ raise ValueError(ERROR_MESSAGES["insufficient_data"])++ returns_array = np.array(returns)+ mean_return = np.mean(returns_array)++ if annualize:+ mean_return *= MathConstants.TRADING_DAYS_YEAR+ risk_free_rate_annual = risk_free_rate+ else:+ risk_free_rate_annual = risk_free_rate / MathConstants.TRADING_DAYS_YEAR++ if beta == 0:+ return 0.0++ return (mean_return - risk_free_rate_annual) / beta++ @staticmethod+ def information_ratio(portfolio_returns: Union[np.ndarray, pd.Series],+ benchmark_returns: Union[np.ndarray, pd.Series]) -> float:+ """Calculate information ratio"""+ excess_returns = np.array(portfolio_returns) - np.array(benchmark_returns)++ if len(excess_returns) < 2:+ raise ValueError(ERROR_MESSAGES["insufficient_data"])++ mean_excess = np.mean(excess_returns)+ std_excess = np.std(excess_returns, ddof=1)++ if std_excess == 0:+ return 0.0++ return mean_excess / std_excess * MathConstants.SQRT_TRADING_DAYS++ @staticmethod+ def jensen_alpha(portfolio_returns: Union[np.ndarray, pd.Series],+ market_returns: Union[np.ndarray, pd.Series],+ beta: float,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> float:+ """Calculate Jensen's alpha"""+ portfolio_mean = np.mean(portfolio_returns) * MathConstants.TRADING_DAYS_YEAR+ market_mean = np.mean(market_returns) * MathConstants.TRADING_DAYS_YEAR++ expected_return = risk_free_rate + beta * (market_mean - risk_free_rate)+ alpha = portfolio_mean - expected_return++ return alpha++ @staticmethod+ def m_squared(portfolio_returns: Union[np.ndarray, pd.Series],+ market_returns: Union[np.ndarray, pd.Series],+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> float:+ """Calculate M-squared (M²) measure"""+ portfolio_sharpe = PerformanceCalculations.sharpe_ratio(portfolio_returns, risk_free_rate)+ market_sharpe = PerformanceCalculations.sharpe_ratio(market_returns, risk_free_rate)+ market_std = np.std(market_returns, ddof=1) * MathConstants.SQRT_TRADING_DAYS++ return (portfolio_sharpe - market_sharpe) * market_std++ @staticmethod+ def sortino_ratio(returns: Union[np.ndarray, pd.Series],+ target_return: float = 0.0,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ annualize: bool = True) -> float:+ """Calculate Sortino ratio"""+ returns_array = np.array(returns)+ excess_returns = returns_array - risk_free_rate / MathConstants.TRADING_DAYS_YEAR+ mean_excess = np.mean(excess_returns)++ downside_dev = StatisticalCalculations.calculate_downside_deviation(+ returns_array, target_return, annualize=False+ )++ if downside_dev == 0:+ return 0.0++ sortino = mean_excess / downside_dev++ if annualize:+ sortino *= MathConstants.SQRT_TRADING_DAYS++ return sortino+++class RiskCalculations:+ """Risk measurement and VaR calculations"""++ @staticmethod+ def value_at_risk_parametric(returns: Union[np.ndarray, pd.Series],+ confidence_level: float = 0.95,+ holding_period: int = 1) -> float:+ """Calculate parametric VaR"""+ returns_array = np.array(returns)+ mean_return = np.mean(returns_array)+ std_return = np.std(returns_array, ddof=1)++ # Z-score for confidence level+ z_score = stats.norm.ppf(1 - confidence_level)++ # VaR calculation+ var = -(mean_return + z_score * std_return) * np.sqrt(holding_period)++ return var++ @staticmethod+ def value_at_risk_historical(returns: Union[np.ndarray, pd.Series],+ confidence_level: float = 0.95,+ holding_period: int = 1) -> float:+ """Calculate historical simulation VaR"""+ returns_array = np.array(returns)++ # Scale for holding period+ if holding_period > 1:+ returns_array = returns_array * np.sqrt(holding_period)++ # Sort returns in ascending order+ sorted_returns = np.sort(returns_array)++ # Find percentile+ percentile = 1 - confidence_level+ var_index = int(np.ceil(len(sorted_returns) * percentile)) - 1+ var_index = max(0, min(var_index, len(sorted_returns) - 1))++ return -sorted_returns[var_index]++ @staticmethod+ def conditional_value_at_risk(returns: Union[np.ndarray, pd.Series],+ confidence_level: float = 0.95,+ method: str = "historical") -> float:+ """Calculate Conditional VaR (Expected Shortfall)"""+ returns_array = np.array(returns)++ if method == "historical":+ var = RiskCalculations.value_at_risk_historical(returns_array, confidence_level)+ tail_returns = returns_array[returns_array <= -var]+ return -np.mean(tail_returns) if len(tail_returns) > 0 else var+ else:+ var = RiskCalculations.value_at_risk_parametric(returns_array, confidence_level)+ # For parametric method, use analytical formula+ z_score = stats.norm.ppf(1 - confidence_level)+ mean_return = np.mean(returns_array)+ std_return = np.std(returns_array, ddof=1)++ cvar = -(mean_return - std_return * stats.norm.pdf(z_score) / (1 - confidence_level))+ return cvar+++class OptimizationEngine:+ """Portfolio optimization algorithms"""++ @staticmethod+ def efficient_frontier(expected_returns: np.ndarray,+ cov_matrix: np.ndarray,+ num_points: int = 100,+ constraints: Optional[Dict] = None) -> Dict:+ """Generate efficient frontier"""+ n_assets = len(expected_returns)++ # Find minimum and maximum return portfolios+ min_var_portfolio = PortfolioMath.find_minimum_variance_portfolio(cov_matrix, constraints)+ min_return = PortfolioMath.calculate_portfolio_return(min_var_portfolio['weights'], expected_returns)++ # Maximum return portfolio (highest expected return asset)+ max_return = np.max(expected_returns)++ # Generate target returns+ target_returns = np.linspace(min_return, max_return, num_points)++ frontier_weights = []+ frontier_returns = []+ frontier_stds = []+ frontier_sharpe = []++ for target_return in target_returns:+ try:+ # Optimize for target return+ def objective(weights):+ return PortfolioMath.calculate_portfolio_variance(weights, cov_matrix)++ # Constraints+ cons = [+ {'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0}, # weights sum to 1+ {'type': 'eq', 'fun': lambda w, tr=target_return:+ PortfolioMath.calculate_portfolio_return(w, expected_returns) - tr}+ ]++ if constraints:+ if 'min_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: w - constraints['min_weight']})+ if 'max_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: constraints['max_weight'] - w})++ bounds = tuple((0, 1) for _ in range(n_assets))+ x0 = np.ones(n_assets) / n_assets++ result = optimize.minimize(objective, x0, method='SLSQP',+ bounds=bounds, constraints=cons,+ options={'maxiter': MathConstants.MAX_ITERATIONS})++ if result.success:+ weights = result.x+ portfolio_return = PortfolioMath.calculate_portfolio_return(weights, expected_returns)+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)+ sharpe = (portfolio_return - MathConstants.DEFAULT_RISK_FREE_RATE) / portfolio_std++ frontier_weights.append(weights)+ frontier_returns.append(portfolio_return)+ frontier_stds.append(portfolio_std)+ frontier_sharpe.append(sharpe)++ except:+ continue++ return {+ 'returns': np.array(frontier_returns),+ 'stds': np.array(frontier_stds),+ 'weights': np.array(frontier_weights),+ 'sharpe_ratios': np.array(frontier_sharpe),+ 'min_var_portfolio': min_var_portfolio+ }++ @staticmethod+ def maximum_sharpe_portfolio(expected_returns: np.ndarray,+ cov_matrix: np.ndarray,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ constraints: Optional[Dict] = None) -> Dict:+ """Find maximum Sharpe ratio portfolio"""+ n_assets = len(expected_returns)++ # Objective function: maximize Sharpe ratio (minimize negative Sharpe)+ def objective(weights):+ portfolio_return = PortfolioMath.calculate_portfolio_return(weights, expected_returns)+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)++ if portfolio_std == 0:+ return -np.inf++ sharpe = (portfolio_return - risk_free_rate) / portfolio_std+ return -sharpe # Minimize negative Sharpe++ # Constraints+ cons = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0}]++ if constraints:+ if 'min_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: w - constraints['min_weight']})+ if 'max_weight' in constraints:+ cons.append({'type': 'ineq', 'fun': lambda w: constraints['max_weight'] - w})++ bounds = tuple((0, 1) for _ in range(n_assets))+ x0 = np.ones(n_assets) / n_assets++ result = optimize.minimize(objective, x0, method='SLSQP',+ bounds=bounds, constraints=cons,+ options={'maxiter': MathConstants.MAX_ITERATIONS})++ if not result.success:+ raise ValueError(ERROR_MESSAGES["optimization_failed"])++ optimal_weights = result.x+ portfolio_return = PortfolioMath.calculate_portfolio_return(optimal_weights, expected_returns)+ portfolio_std = PortfolioMath.calculate_portfolio_std(optimal_weights, cov_matrix)+ sharpe = (portfolio_return - risk_free_rate) / portfolio_std++ return {+ 'weights': optimal_weights,+ 'expected_return': portfolio_return,+ 'std': portfolio_std,+ 'sharpe_ratio': sharpe,+ 'optimization_result': result+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_analytics.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_analytics.pynew file mode 100644index 000000000..ef08100de--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_analytics.py@@ -0,0 +1,675 @@+"""+Portfolio Analytics Module+==========================++Comprehensive portfolio risk and return analysis compliant with CFA Institute standards.+Provides modern portfolio theory implementation, performance attribution, risk metrics,+and portfolio optimization capabilities for multi-asset investment portfolios with+advanced analytics and reporting features.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction data+ - Asset price series and market returns+ - Benchmark indices and market data+ - Risk-free rates and economic indicators+ - Portfolio constraints and investment policy++OUTPUT:+ - Portfolio performance metrics (returns, volatility, Sharpe ratio)+ - Risk decomposition and attribution analysis+ - Efficient frontier and optimization results+ - Performance attribution vs benchmarks+ - Portfolio analytics reports and visualizations++PARAMETERS:+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - confidence_level: VaR confidence level (default: 0.95)+ - benchmark: Portfolio benchmark index (default: 'SPY')+ - rebalance_frequency: Rebalancing frequency (default: 'monthly')+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - lookback_period: Historical lookback window (default: 252)+ - currency: Portfolio base currency (default: 'USD')+"""++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple+import warnings++from config import (+ AssetClass, MathConstants, PortfolioParameters,+ DEFAULT_PORTFOLIO_PARAMS, validate_weights, ERROR_MESSAGES+)+from math_engine import (+ StatisticalCalculations, PortfolioMath, PerformanceCalculations,+ RiskCalculations, OptimizationEngine+)+++class AssetClassAnalysis:+ """Major asset class characteristics and analysis"""++ ASSET_CLASS_PROPERTIES = {+ AssetClass.EQUITY: {+ "expected_return_range": (0.06, 0.12),+ "volatility_range": (0.15, 0.25),+ "liquidity": "high",+ "inflation_hedge": "moderate",+ "correlation_with_bonds": -0.2+ },+ AssetClass.FIXED_INCOME: {+ "expected_return_range": (0.02, 0.06),+ "volatility_range": (0.03, 0.08),+ "liquidity": "high",+ "inflation_hedge": "poor",+ "correlation_with_equity": -0.2+ },+ AssetClass.COMMODITIES: {+ "expected_return_range": (0.03, 0.08),+ "volatility_range": (0.20, 0.35),+ "liquidity": "moderate",+ "inflation_hedge": "good",+ "correlation_with_equity": 0.3+ },+ AssetClass.REAL_ESTATE: {+ "expected_return_range": (0.04, 0.10),+ "volatility_range": (0.12, 0.20),+ "liquidity": "low",+ "inflation_hedge": "good",+ "correlation_with_equity": 0.6+ }+ }++ @classmethod+ def get_asset_characteristics(cls, asset_class: AssetClass) -> Dict:+ """Get characteristics of major asset classes"""+ return cls.ASSET_CLASS_PROPERTIES.get(asset_class, {})++ @classmethod+ def analyze_diversification_benefits(cls, asset_classes: List[AssetClass]) -> Dict:+ """Analyze diversification benefits across asset classes"""+ correlations = {}+ total_pairs = 0+ sum_correlations = 0++ for i, asset1 in enumerate(asset_classes):+ for j, asset2 in enumerate(asset_classes[i + 1:], i + 1):+ # Get correlation estimates between asset classes+ if asset1 == AssetClass.EQUITY and asset2 == AssetClass.FIXED_INCOME:+ corr = cls.ASSET_CLASS_PROPERTIES[AssetClass.EQUITY]["correlation_with_bonds"]+ elif asset1 == AssetClass.FIXED_INCOME and asset2 == AssetClass.EQUITY:+ corr = cls.ASSET_CLASS_PROPERTIES[AssetClass.FIXED_INCOME]["correlation_with_equity"]+ elif asset1 == AssetClass.COMMODITIES and asset2 == AssetClass.EQUITY:+ corr = cls.ASSET_CLASS_PROPERTIES[AssetClass.COMMODITIES]["correlation_with_equity"]+ elif asset1 == AssetClass.REAL_ESTATE and asset2 == AssetClass.EQUITY:+ corr = cls.ASSET_CLASS_PROPERTIES[AssetClass.REAL_ESTATE]["correlation_with_equity"]+ else:+ corr = 0.5 # Default moderate correlation++ correlations[f"{asset1.value}_{asset2.value}"] = corr+ sum_correlations += abs(corr)+ total_pairs += 1++ avg_correlation = sum_correlations / total_pairs if total_pairs > 0 else 0+ diversification_ratio = 1 - avg_correlation++ return {+ "pairwise_correlations": correlations,+ "average_correlation": avg_correlation,+ "diversification_ratio": diversification_ratio,+ "diversification_benefit": "High" if diversification_ratio > 0.7 else+ "Moderate" if diversification_ratio > 0.4 else "Low"+ }+++class RiskAversionAnalysis:+ """Risk aversion modeling and utility analysis"""++ @staticmethod+ def utility_function(return_value: float, variance: float,+ risk_aversion: float, function_type: str = "quadratic") -> float:+ """Calculate utility based on return and risk"""+ if function_type == "quadratic":+ # U = E(R) - (A/2) * Var(R)+ return return_value - (risk_aversion / 2) * variance+ elif function_type == "exponential":+ # U = -exp(-A * E(R))+ return -np.exp(-risk_aversion * return_value)+ elif function_type == "log":+ # U = ln(1 + R) for positive returns+ if return_value > -1:+ return np.log(1 + return_value)+ else:+ return -np.inf+ else:+ raise ValueError("Function type must be 'quadratic', 'exponential', or 'log'")++ @staticmethod+ def certainty_equivalent(expected_return: float, variance: float,+ risk_aversion: float) -> float:+ """Calculate certainty equivalent return"""+ return expected_return - (risk_aversion / 2) * variance++ @staticmethod+ def risk_premium(expected_return: float, risk_free_rate: float,+ variance: float, risk_aversion: float) -> float:+ """Calculate required risk premium"""+ return (risk_aversion / 2) * variance++ @classmethod+ def optimal_portfolio_selection(cls, expected_returns: np.ndarray,+ cov_matrix: np.ndarray,+ risk_aversion: float,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> Dict:+ """Find optimal portfolio for given risk aversion"""+ n_assets = len(expected_returns)++ # Objective: maximize utility U = w'μ - (A/2)w'Σw+ def objective(weights):+ portfolio_return = PortfolioMath.calculate_portfolio_return(weights, expected_returns)+ portfolio_variance = PortfolioMath.calculate_portfolio_variance(weights, cov_matrix)+ utility = cls.utility_function(portfolio_return, portfolio_variance, risk_aversion)+ return -utility # Minimize negative utility++ from scipy import optimize++ # Constraints+ cons = [{'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0}]+ bounds = tuple((0, 1) for _ in range(n_assets))+ x0 = np.ones(n_assets) / n_assets++ result = optimize.minimize(objective, x0, method='SLSQP',+ bounds=bounds, constraints=cons)++ if result.success:+ weights = result.x+ portfolio_return = PortfolioMath.calculate_portfolio_return(weights, expected_returns)+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)+ portfolio_variance = portfolio_std ** 2+ utility = cls.utility_function(portfolio_return, portfolio_variance, risk_aversion)+ ce_return = cls.certainty_equivalent(portfolio_return, portfolio_variance, risk_aversion)++ return {+ "optimal_weights": weights,+ "expected_return": portfolio_return,+ "standard_deviation": portfolio_std,+ "variance": portfolio_variance,+ "utility": utility,+ "certainty_equivalent": ce_return,+ "risk_premium": portfolio_return - risk_free_rate+ }+ else:+ raise ValueError(ERROR_MESSAGES["optimization_failed"])+++class CapitalAllocationLine:+ """Capital Allocation Line (CAL) and Capital Market Line (CML) analysis"""++ @staticmethod+ def calculate_cal(risky_portfolio_return: float,+ risky_portfolio_std: float,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> Dict:+ """Calculate Capital Allocation Line parameters"""+ slope = (risky_portfolio_return - risk_free_rate) / risky_portfolio_std++ return {+ "intercept": risk_free_rate,+ "slope": slope,+ "sharpe_ratio": slope,+ "risky_return": risky_portfolio_return,+ "risky_std": risky_portfolio_std+ }++ @staticmethod+ def optimal_allocation(target_return: Optional[float] = None,+ target_std: Optional[float] = None,+ risky_portfolio_return: float = None,+ risky_portfolio_std: float = None,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> Dict:+ """Find optimal allocation between risk-free and risky assets"""+ if target_return is not None:+ # Given target return, find allocation+ y = (target_return - risk_free_rate) / (risky_portfolio_return - risk_free_rate)+ portfolio_std = y * risky_portfolio_std++ elif target_std is not None:+ # Given target standard deviation, find allocation+ y = target_std / risky_portfolio_std+ portfolio_return = risk_free_rate + y * (risky_portfolio_return - risk_free_rate)+ target_return = portfolio_return++ else:+ raise ValueError("Either target_return or target_std must be specified")++ # Ensure valid allocation+ y = max(0, y) # No short selling risk-free asset++ return {+ "risky_asset_weight": y,+ "risk_free_weight": 1 - y,+ "portfolio_return": target_return,+ "portfolio_std": target_std if target_std else portfolio_std,+ "leveraged": y > 1.0+ }+++class SystematicRiskAnalysis:+ """Systematic vs. Nonsystematic risk analysis"""++ @staticmethod+ def decompose_risk(asset_returns: np.ndarray,+ market_returns: np.ndarray) -> Dict:+ """Decompose total risk into systematic and nonsystematic components"""+ beta = StatisticalCalculations.calculate_beta(asset_returns, market_returns)++ # Total variance+ total_variance = StatisticalCalculations.calculate_variance(asset_returns)++ # Market variance+ market_variance = StatisticalCalculations.calculate_variance(market_returns)++ # Systematic variance = β² * σ²ₘ+ systematic_variance = (beta ** 2) * market_variance++ # Nonsystematic variance = Total - Systematic+ nonsystematic_variance = total_variance - systematic_variance++ # R-squared (proportion of variance explained by market)+ correlation = StatisticalCalculations.calculate_correlation(asset_returns, market_returns)+ r_squared = correlation ** 2++ return {+ "beta": beta,+ "total_variance": total_variance,+ "total_std": np.sqrt(total_variance),+ "systematic_variance": systematic_variance,+ "systematic_std": np.sqrt(systematic_variance),+ "nonsystematic_variance": max(0, nonsystematic_variance),+ "nonsystematic_std": np.sqrt(max(0, nonsystematic_variance)),+ "r_squared": r_squared,+ "systematic_risk_percentage": systematic_variance / total_variance * 100,+ "nonsystematic_risk_percentage": max(0, nonsystematic_variance) / total_variance * 100+ }++ @staticmethod+ def portfolio_beta(individual_betas: np.ndarray, weights: np.ndarray) -> float:+ """Calculate portfolio beta as weighted average of individual betas"""+ if not validate_weights(weights):+ raise ValueError(ERROR_MESSAGES["invalid_weights"])+ return np.dot(weights, individual_betas)+++class CAPMAnalysis:+ """Capital Asset Pricing Model implementation"""++ @staticmethod+ def expected_return(beta: float,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ market_return: float = 0.10) -> float:+ """Calculate expected return using CAPM"""+ return risk_free_rate + beta * (market_return - risk_free_rate)++ @staticmethod+ def security_market_line(betas: np.ndarray,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE,+ market_return: float = 0.10) -> np.ndarray:+ """Generate Security Market Line for given betas"""+ return risk_free_rate + betas * (market_return - risk_free_rate)++ @staticmethod+ def alpha_calculation(actual_returns: np.ndarray,+ market_returns: np.ndarray,+ risk_free_rate: float = MathConstants.DEFAULT_RISK_FREE_RATE) -> Dict:+ """Calculate Jensen's alpha and related metrics"""+ beta = StatisticalCalculations.calculate_beta(actual_returns, market_returns)++ # Average returns (annualized)+ avg_actual_return = np.mean(actual_returns) * MathConstants.TRADING_DAYS_YEAR+ avg_market_return = np.mean(market_returns) * MathConstants.TRADING_DAYS_YEAR++ # Expected return from CAPM+ expected_return = CAPMAnalysis.expected_return(beta, risk_free_rate, avg_market_return)++ # Alpha+ alpha = avg_actual_return - expected_return++ return {+ "alpha": alpha,+ "beta": beta,+ "actual_return": avg_actual_return,+ "expected_return": expected_return,+ "market_return": avg_market_return,+ "excess_return": avg_actual_return - risk_free_rate,+ "market_premium": avg_market_return - risk_free_rate+ }++ @staticmethod+ def capm_assumptions_check(returns_data: Dict[str, np.ndarray]) -> Dict:+ """Check CAPM assumptions validity"""+ assumptions = {+ "homogeneous_expectations": "Cannot verify with historical data",+ "single_period_model": "Using historical multi-period data",+ "risk_free_borrowing_lending": "Assumed available",+ "no_transaction_costs": "Assumed",+ "normal_distribution": {},+ "constant_correlations": {}+ }++ # Test normality+ from scipy import stats+ for asset, returns in returns_data.items():+ shapiro_stat, shapiro_p = stats.shapiro(returns[:min(5000, len(returns))])+ assumptions["normal_distribution"][asset] = {+ "shapiro_test_p_value": shapiro_p,+ "approximately_normal": shapiro_p > 0.05+ }++ # Test correlation stability (split sample)+ if len(returns_data) >= 2:+ assets = list(returns_data.keys())+ asset1_returns = returns_data[assets[0]]+ asset2_returns = returns_data[assets[1]]++ mid_point = len(asset1_returns) // 2+ corr1 = StatisticalCalculations.calculate_correlation(+ asset1_returns[:mid_point], asset2_returns[:mid_point]+ )+ corr2 = StatisticalCalculations.calculate_correlation(+ asset1_returns[mid_point:], asset2_returns[mid_point:]+ )++ assumptions["constant_correlations"] = {+ "first_half_correlation": corr1,+ "second_half_correlation": corr2,+ "correlation_difference": abs(corr1 - corr2),+ "stable_correlations": abs(corr1 - corr2) < 0.2+ }++ return assumptions+++class EfficientFrontierAnalysis:+ """Efficient frontier construction and analysis"""++ def __init__(self, expected_returns: np.ndarray, cov_matrix: np.ndarray,+ parameters: PortfolioParameters = DEFAULT_PORTFOLIO_PARAMS):+ self.expected_returns = expected_returns+ self.cov_matrix = cov_matrix+ self.parameters = parameters+ self.n_assets = len(expected_returns)++ if not validate_covariance_matrix(cov_matrix):+ raise ValueError(ERROR_MESSAGES["singular_matrix"])++ def generate_frontier(self) -> Dict:+ """Generate complete efficient frontier"""+ # Find minimum variance portfolio+ min_var_result = PortfolioMath.find_minimum_variance_portfolio(+ self.cov_matrix,+ {+ 'min_weight': self.parameters.min_weight,+ 'max_weight': self.parameters.max_weight+ }+ )++ # Generate efficient frontier+ frontier_result = OptimizationEngine.efficient_frontier(+ self.expected_returns,+ self.cov_matrix,+ self.parameters.num_frontier_points,+ {+ 'min_weight': self.parameters.min_weight,+ 'max_weight': self.parameters.max_weight+ }+ )++ # Find maximum Sharpe portfolio+ max_sharpe_result = OptimizationEngine.maximum_sharpe_portfolio(+ self.expected_returns,+ self.cov_matrix,+ self.parameters.risk_free_rate,+ {+ 'min_weight': self.parameters.min_weight,+ 'max_weight': self.parameters.max_weight+ }+ )++ return {+ "frontier_returns": frontier_result["returns"],+ "frontier_stds": frontier_result["stds"],+ "frontier_weights": frontier_result["weights"],+ "frontier_sharpe_ratios": frontier_result["sharpe_ratios"],+ "min_variance_portfolio": min_var_result,+ "max_sharpe_portfolio": max_sharpe_result,+ "capital_market_line": self._calculate_cml(max_sharpe_result)+ }++ def _calculate_cml(self, max_sharpe_portfolio: Dict) -> Dict:+ """Calculate Capital Market Line parameters"""+ return CapitalAllocationLine.calculate_cal(+ max_sharpe_portfolio["expected_return"],+ max_sharpe_portfolio["std"],+ self.parameters.risk_free_rate+ )++ def portfolio_on_frontier(self, target_return: float) -> Dict:+ """Find specific portfolio on efficient frontier"""+ from scipy import optimize++ def objective(weights):+ return PortfolioMath.calculate_portfolio_variance(weights, self.cov_matrix)++ # Constraints+ cons = [+ {'type': 'eq', 'fun': lambda w: np.sum(w) - 1.0},+ {'type': 'eq', 'fun': lambda w:+ PortfolioMath.calculate_portfolio_return(w, self.expected_returns) - target_return}+ ]++ bounds = tuple((self.parameters.min_weight, self.parameters.max_weight)+ for _ in range(self.n_assets))+ x0 = np.ones(self.n_assets) / self.n_assets++ result = optimize.minimize(objective, x0, method='SLSQP',+ bounds=bounds, constraints=cons)++ if result.success:+ weights = result.x+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, self.cov_matrix)+ sharpe_ratio = (target_return - self.parameters.risk_free_rate) / portfolio_std++ return {+ "weights": weights,+ "expected_return": target_return,+ "standard_deviation": portfolio_std,+ "sharpe_ratio": sharpe_ratio,+ "on_efficient_frontier": True+ }+ else:+ return {"on_efficient_frontier": False, "error": "Optimization failed"}+++class CorrelationEffectsAnalysis:+ """Analysis of correlation effects on portfolio risk"""++ @staticmethod+ def correlation_impact(weights: np.ndarray,+ individual_stds: np.ndarray,+ correlation_matrix: np.ndarray) -> Dict:+ """Analyze impact of correlations on portfolio risk"""+ # Portfolio standard deviation with actual correlations+ cov_matrix = np.outer(individual_stds, individual_stds) * correlation_matrix+ actual_portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)++ # Portfolio standard deviation if perfectly correlated (ρ = 1)+ perfect_corr_matrix = np.ones_like(correlation_matrix)+ perfect_cov_matrix = np.outer(individual_stds, individual_stds) * perfect_corr_matrix+ perfect_corr_std = PortfolioMath.calculate_portfolio_std(weights, perfect_cov_matrix)++ # Portfolio standard deviation if uncorrelated (ρ = 0)+ zero_corr_matrix = np.eye(len(correlation_matrix))+ zero_cov_matrix = np.outer(individual_stds, individual_stds) * zero_corr_matrix+ zero_corr_std = PortfolioMath.calculate_portfolio_std(weights, zero_cov_matrix)++ # Diversification benefit+ weighted_avg_std = np.dot(weights, individual_stds)+ diversification_ratio = PortfolioMath.calculate_diversification_ratio(+ weights, individual_stds, actual_portfolio_std+ )++ return {+ "actual_portfolio_std": actual_portfolio_std,+ "perfect_correlation_std": perfect_corr_std,+ "zero_correlation_std": zero_corr_std,+ "weighted_average_std": weighted_avg_std,+ "diversification_ratio": diversification_ratio,+ "risk_reduction_vs_perfect_corr": (perfect_corr_std - actual_portfolio_std) / perfect_corr_std,+ "risk_reduction_vs_weighted_avg": (weighted_avg_std - actual_portfolio_std) / weighted_avg_std,+ "average_correlation": np.mean(correlation_matrix[correlation_matrix != 1.0])+ }++ @staticmethod+ def optimal_correlation_for_risk_target(weights: np.ndarray,+ individual_stds: np.ndarray,+ target_portfolio_std: float) -> float:+ """Find correlation needed to achieve target portfolio standard deviation"""++ # This assumes equal correlation between all pairs+ def objective(avg_correlation):+ # Create correlation matrix with average correlation+ n = len(weights)+ corr_matrix = np.full((n, n), avg_correlation)+ np.fill_diagonal(corr_matrix, 1.0)++ # Calculate portfolio std+ cov_matrix = np.outer(individual_stds, individual_stds) * corr_matrix+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)++ return (portfolio_std - target_portfolio_std) ** 2++ from scipy import optimize++ result = optimize.minimize_scalar(objective, bounds=(-1, 1), method='bounded')++ return result.x if result.success else None+++class PortfolioAnalytics:+ """Main portfolio analytics interface"""++ def __init__(self, parameters: PortfolioParameters = DEFAULT_PORTFOLIO_PARAMS):+ self.parameters = parameters++ def comprehensive_analysis(self, returns_data: Dict[str, np.ndarray],+ weights: Optional[np.ndarray] = None,+ market_returns: Optional[np.ndarray] = None) -> Dict:+ """Perform comprehensive portfolio analysis"""+ # Convert returns to matrix format+ returns_df = pd.DataFrame(returns_data)+ returns_matrix = returns_df.dropna().values+ asset_names = list(returns_data.keys())++ # Calculate basic statistics+ expected_returns = np.mean(returns_matrix, axis=0) * MathConstants.TRADING_DAYS_YEAR+ cov_matrix = np.cov(returns_matrix.T) * MathConstants.TRADING_DAYS_YEAR+ corr_matrix = np.corrcoef(returns_matrix.T)+ individual_stds = np.sqrt(np.diag(cov_matrix))++ # Default equal weights if not provided+ if weights is None:+ weights = np.ones(len(asset_names)) / len(asset_names)++ # Portfolio statistics+ portfolio_return = PortfolioMath.calculate_portfolio_return(weights, expected_returns)+ portfolio_std = PortfolioMath.calculate_portfolio_std(weights, cov_matrix)+ portfolio_sharpe = PerformanceCalculations.sharpe_ratio(+ np.dot(returns_matrix, weights), self.parameters.risk_free_rate+ )++ results = {+ "basic_statistics": {+ "asset_names": asset_names,+ "expected_returns": expected_returns,+ "volatilities": individual_stds,+ "correlation_matrix": corr_matrix,+ "covariance_matrix": cov_matrix+ },+ "portfolio_metrics": {+ "weights": weights,+ "expected_return": portfolio_return,+ "standard_deviation": portfolio_std,+ "variance": portfolio_std ** 2,+ "sharpe_ratio": portfolio_sharpe+ }+ }++ # Correlation effects analysis+ correlation_analysis = CorrelationEffectsAnalysis.correlation_impact(+ weights, individual_stds, corr_matrix+ )+ results["correlation_analysis"] = correlation_analysis++ # Efficient frontier analysis+ try:+ frontier_analyzer = EfficientFrontierAnalysis(expected_returns, cov_matrix, self.parameters)+ frontier_results = frontier_analyzer.generate_frontier()+ results["efficient_frontier"] = frontier_results+ except Exception as e:+ results["efficient_frontier"] = {"error": str(e)}++ # CAPM analysis if market returns provided+ if market_returns is not None:+ portfolio_returns = np.dot(returns_matrix, weights)+ capm_results = CAPMAnalysis.alpha_calculation(+ portfolio_returns, market_returns, self.parameters.risk_free_rate+ )++ # Individual asset betas+ individual_betas = []+ for i in range(len(asset_names)):+ beta = StatisticalCalculations.calculate_beta(returns_matrix[:, i], market_returns)+ individual_betas.append(beta)++ # Systematic risk decomposition+ systematic_analysis = SystematicRiskAnalysis.decompose_risk(+ portfolio_returns, market_returns+ )++ results["capm_analysis"] = capm_results+ results["individual_betas"] = dict(zip(asset_names, individual_betas))+ results["systematic_risk_analysis"] = systematic_analysis++ # Risk metrics+ portfolio_returns = np.dot(returns_matrix, weights)+ var_95 = RiskCalculations.value_at_risk_historical(portfolio_returns, 0.95)+ var_99 = RiskCalculations.value_at_risk_historical(portfolio_returns, 0.99)+ cvar_95 = RiskCalculations.conditional_value_at_risk(portfolio_returns, 0.95)++ results["risk_metrics"] = {+ "value_at_risk_95": var_95,+ "value_at_risk_99": var_99,+ "conditional_var_95": cvar_95,+ "maximum_drawdown": self._calculate_max_drawdown(portfolio_returns)+ }++ return results++ def _calculate_max_drawdown(self, returns: np.ndarray) -> Dict:+ """Calculate maximum drawdown"""+ cumulative_returns = np.cumprod(1 + returns)+ running_max = np.maximum.accumulate(cumulative_returns)+ drawdown = (cumulative_returns - running_max) / running_max++ max_dd = np.min(drawdown)+ max_dd_idx = np.argmin(drawdown)++ # Find peak before max drawdown+ peak_idx = np.argmax(running_max[:max_dd_idx + 1])++ return {+ "max_drawdown": max_dd,+ "peak_index": peak_idx,+ "trough_index": max_dd_idx,+ "recovery_time": None # Would need to calculate recovery+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_management.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_management.pynew file mode 100644index 000000000..dc1339b9e--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_management.py@@ -0,0 +1,1258 @@++Portfolio Portfolio Management Module+===============================++Core portfolio management functionality++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple+from dataclasses import dataclass+from enum import Enum+from datetime import datetime, timedelta++from config import AssetClass, MathConstants++class InvestorType(Enum):+ """Types of investors and their characteristics"""+ INDIVIDUAL = "individual"+ INSTITUTIONAL = "institutional"+ PENSION_FUND = "pension_fund"+ ENDOWMENT = "endowment"+ FOUNDATION = "foundation"+ INSURANCE_COMPANY = "insurance_company"+ BANK = "bank"+ SOVEREIGN_WEALTH_FUND = "sovereign_wealth_fund"++class InvestmentObjective(Enum):+ """Primary investment objectives"""+ CAPITAL_PRESERVATION = "capital_preservation"+ CAPITAL_APPRECIATION = "capital_appreciation"+ CURRENT_INCOME = "current_income"+ TOTAL_RETURN = "total_return"++class LifecycleStage(Enum):+ """Individual investor lifecycle stages"""+ ACCUMULATION = "accumulation"+ CONSOLIDATION = "consolidation"+ SPENDING = "spending"+ GIFTING = "gifting"++@dataclass+class InvestorProfile:+ """Comprehensive investor profile"""+ investor_type: InvestorType+ investment_objective: InvestmentObjective+ risk_tolerance: str+ time_horizon: int+ liquidity_needs: float+ tax_situation: Dict+ regulatory_constraints: List[str]+ unique_circumstances: List[str]++class PortfolioApproach:+ """Portfolio approach to investing principles"""++ @staticmethod+ def diversification_benefits() -> Dict:+ """Explain diversification benefits in portfolio approach"""+ return {+ "risk_reduction": {+ "description": "Diversification reduces portfolio risk without proportionally reducing expected return",+ "mathematical_basis": "Portfolio variance < weighted average of individual variances when correlations < 1",+ "optimal_diversification": "Achieved when marginal risk reduction equals marginal cost"+ },+ "correlation_importance": {+ "description": "Lower correlations between assets provide greater diversification benefits",+ "perfect_correlation": "No diversification benefit (ρ = 1)",+ "zero_correlation": "Significant risk reduction possible (ρ = 0)",+ "negative_correlation": "Maximum diversification benefit (ρ < 0)"+ },+ "asset_class_diversification": {+ "description": "Diversification across asset classes provides better risk-return trade-offs",+ "geographic_diversification": "Reduces country-specific risks",+ "currency_diversification": "Reduces currency risk exposure",+ "sector_diversification": "Reduces industry-specific risks"+ }+ }++ @staticmethod+ def portfolio_vs_security_analysis() -> Dict:+ """Compare portfolio approach vs. individual security analysis"""+ return {+ "portfolio_approach": {+ "focus": "Risk-return characteristics of portfolio as a whole",+ "risk_measure": "Portfolio variance and covariances between assets",+ "optimization": "Maximize utility given risk tolerance constraints",+ "diversification": "Central to approach - systematic risk reduction"+ },+ "security_analysis": {+ "focus": "Individual security characteristics and valuation",+ "risk_measure": "Individual security variance and fundamental risks",+ "optimization": "Find undervalued securities with attractive risk-return",+ "diversification": "May be considered but not central focus"+ },+ "integration": {+ "modern_approach": "Combine both approaches for optimal results",+ "top_down": "Asset allocation first, then security selection",+ "bottom_up": "Security selection within asset allocation framework"+ }+ }++class PortfolioManagementProcess:+ """Portfolio management process steps and framework"""++ def __init__(self):+ self.process_steps = [+ "planning", "execution", "feedback"+ ]+ self.planning_substeps = [+ "understand_client_needs", "study_market_conditions",+ "construct_strategic_asset_allocation", "construct_portfolio"+ ]++ def planning_step(self, client_profile: InvestorProfile) -> Dict:+ """Execute planning step of portfolio management process"""+ return {+ "client_needs_analysis": self._analyze_client_needs(client_profile),+ "market_conditions_study": self._study_market_conditions(),+ "strategic_asset_allocation": self._construct_strategic_allocation(client_profile),+ "portfolio_construction_guidelines": self._portfolio_construction_guidelines(client_profile)+ }++ def execution_step(self, allocation_targets: Dict, market_conditions: Dict) -> Dict:+ """Execute execution step of portfolio management process"""+ return {+ "asset_allocation_decisions": self._make_allocation_decisions(allocation_targets),+ "security_selection": self._security_selection_process(allocation_targets),+ "implementation_strategy": self._implementation_strategy(market_conditions),+ "trading_considerations": self._trading_considerations()+ }++ def feedback_step(self, portfolio_performance: Dict, benchmarks: Dict) -> Dict:+ """Execute feedback step of portfolio management process"""+ return {+ "performance_measurement": self._measure_performance(portfolio_performance, benchmarks),+ "performance_evaluation": self._evaluate_performance(portfolio_performance),+ "portfolio_monitoring": self._monitor_portfolio(),+ "rebalancing_needs": self._assess_rebalancing_needs(portfolio_performance)+ }++ def _analyze_client_needs(self, client_profile: InvestorProfile) -> Dict:+ """Analyze client needs and circumstances"""+ return {+ "investment_objectives": {+ "primary_objective": client_profile.investment_objective.value,+ "secondary_objectives": self._identify_secondary_objectives(client_profile),+ "objective_prioritization": self._prioritize_objectives(client_profile)+ },+ "constraints_analysis": {+ "liquidity_constraints": self._analyze_liquidity_needs(client_profile),+ "time_horizon_analysis": self._analyze_time_horizon(client_profile),+ "tax_considerations": self._analyze_tax_situation(client_profile),+ "regulatory_constraints": client_profile.regulatory_constraints,+ "unique_circumstances": client_profile.unique_circumstances+ },+ "risk_analysis": {+ "risk_tolerance_assessment": client_profile.risk_tolerance,+ "risk_capacity_vs_willingness": self._assess_risk_capacity_willingness(client_profile),+ "risk_budget_allocation": self._allocate_risk_budget(client_profile)+ }+ }++ def _study_market_conditions(self) -> Dict:+ """Study current market conditions"""+ return {+ "economic_environment": {+ "gdp_growth": "Current economic growth trends",+ "inflation_expectations": "Inflation outlook and implications",+ "interest_rate_environment": "Current and expected interest rate levels",+ "business_cycle_stage": "Current phase of business cycle"+ },+ "market_conditions": {+ "equity_market_valuation": "Current equity market valuation levels",+ "bond_market_conditions": "Interest rate and credit spread environment",+ "volatility_levels": "Current market volatility and risk premiums",+ "liquidity_conditions": "Market liquidity and trading conditions"+ },+ "outlook_assessment": {+ "short_term_outlook": "1-12 month market outlook",+ "medium_term_outlook": "1-5 year market outlook",+ "long_term_outlook": "5+ year structural trends"+ }+ }++ def _construct_strategic_allocation(self, client_profile: InvestorProfile) -> Dict:+ """Construct strategic asset allocation"""+ # Basic allocation based on investor type and objectives+ if client_profile.investor_type == InvestorType.INDIVIDUAL:+ base_allocation = self._individual_allocation_framework(client_profile)+ elif client_profile.investor_type == InvestorType.PENSION_FUND:+ base_allocation = self._pension_allocation_framework(client_profile)+ elif client_profile.investor_type == InvestorType.ENDOWMENT:+ base_allocation = self._endowment_allocation_framework(client_profile)+ else:+ base_allocation = self._default_allocation_framework(client_profile)++ return {+ "strategic_weights": base_allocation,+ "rebalancing_ranges": self._set_rebalancing_ranges(base_allocation),+ "allocation_rationale": self._explain_allocation_rationale(client_profile, base_allocation),+ "expected_portfolio_characteristics": self._calculate_expected_characteristics(base_allocation)+ }++ def _individual_allocation_framework(self, profile: InvestorProfile) -> Dict[str, float]:+ """Asset allocation framework for individual investors"""+ # Age-based equity allocation rule of thumb: 100 - age = equity %+ if hasattr(profile, 'age'):+ equity_base = max(20, min(80, 100 - profile.age))+ else:+ # Use time horizon as proxy+ equity_base = max(20, min(80, profile.time_horizon * 5))++ # Adjust based on risk tolerance+ risk_adjustments = {+ "conservative": -20,+ "moderate": 0,+ "aggressive": +15+ }+ equity_allocation = equity_base + risk_adjustments.get(profile.risk_tolerance, 0)+ equity_allocation = max(10, min(90, equity_allocation)) / 100++ return {+ "domestic_equity": equity_allocation * 0.6,+ "international_equity": equity_allocation * 0.4,+ "domestic_bonds": (1 - equity_allocation) * 0.7,+ "international_bonds": (1 - equity_allocation) * 0.2,+ "cash": (1 - equity_allocation) * 0.1+ }++ def _pension_allocation_framework(self, profile: InvestorProfile) -> Dict[str, float]:+ """Asset allocation framework for pension funds"""+ return {+ "domestic_equity": 0.35,+ "international_equity": 0.25,+ "domestic_bonds": 0.25,+ "real_estate": 0.10,+ "alternatives": 0.05+ }++ def _endowment_allocation_framework(self, profile: InvestorProfile) -> Dict[str, float]:+ """Asset allocation framework for endowments"""+ return {+ "domestic_equity": 0.25,+ "international_equity": 0.20,+ "domestic_bonds": 0.15,+ "real_estate": 0.15,+ "private_equity": 0.15,+ "hedge_funds": 0.10+ }++ def _default_allocation_framework(self, profile: InvestorProfile) -> Dict[str, float]:+ """Default balanced allocation framework"""+ return {+ "domestic_equity": 0.40,+ "international_equity": 0.20,+ "domestic_bonds": 0.30,+ "cash": 0.10+ }++class InvestorClassification:+ """Classification and characteristics of different investor types"""++ INVESTOR_CHARACTERISTICS = {+ InvestorType.INDIVIDUAL: {+ "typical_objectives": [InvestmentObjective.CAPITAL_APPRECIATION, InvestmentObjective.TOTAL_RETURN],+ "time_horizon": "Variable (accumulation to spending phase)",+ "liquidity_needs": "Generally high",+ "tax_considerations": "Highly relevant",+ "regulatory_constraints": "Minimal",+ "risk_tolerance": "Wide range",+ "typical_constraints": ["Behavioral biases", "Limited investment knowledge", "Tax implications"]+ },+ InvestorType.PENSION_FUND: {+ "typical_objectives": [InvestmentObjective.TOTAL_RETURN],+ "time_horizon": "Long-term",+ "liquidity_needs": "Predictable cash flows",+ "tax_considerations": "Often tax-exempt",+ "regulatory_constraints": "ERISA and other regulations",+ "risk_tolerance": "Moderate to high",+ "typical_constraints": ["Regulatory limits", "Liability matching", "Funding ratio considerations"]+ },+ InvestorType.ENDOWMENT: {+ "typical_objectives": [InvestmentObjective.TOTAL_RETURN],+ "time_horizon": "Perpetual",+ "liquidity_needs": "Annual spending requirements",+ "tax_considerations": "Tax-exempt",+ "regulatory_constraints": "UPMIFA and state regulations",+ "risk_tolerance": "High",+ "typical_constraints": ["Spending policy", "Intergenerational equity", "Mission alignment"]+ },+ InvestorType.INSURANCE_COMPANY: {+ "typical_objectives": [InvestmentObjective.CURRENT_INCOME],+ "time_horizon": "Liability-driven",+ "liquidity_needs": "Claims-driven",+ "tax_considerations": "Corporate tax rates",+ "regulatory_constraints": "Insurance regulations",+ "risk_tolerance": "Conservative",+ "typical_constraints": ["Asset-liability matching", "Regulatory capital", "Credit quality requirements"]+ }+ }++ @classmethod+ def get_investor_characteristics(cls, investor_type: InvestorType) -> Dict:+ """Get characteristics for specific investor type"""+ return cls.INVESTOR_CHARACTERISTICS.get(investor_type, {})++ @classmethod+ def compare_investor_types(cls, investor_types: List[InvestorType]) -> Dict:+ """Compare characteristics across investor types"""+ comparison = {}++ for investor_type in investor_types:+ comparison[investor_type.value] = cls.get_investor_characteristics(investor_type)++ return comparison++ @classmethod+ def lifecycle_analysis(cls, current_stage: LifecycleStage, age: int,+ financial_situation: Dict) -> Dict:+ """Analyze individual investor lifecycle stage"""+ lifecycle_characteristics = {+ LifecycleStage.ACCUMULATION: {+ "typical_age_range": "20-45",+ "primary_objective": InvestmentObjective.CAPITAL_APPRECIATION,+ "risk_tolerance": "High",+ "time_horizon": "Long",+ "liquidity_needs": "Low",+ "investment_focus": "Growth assets, tax-deferred savings"+ },+ LifecycleStage.CONSOLIDATION: {+ "typical_age_range": "45-60",+ "primary_objective": InvestmentObjective.TOTAL_RETURN,+ "risk_tolerance": "Moderate to High",+ "time_horizon": "Medium to Long",+ "liquidity_needs": "Moderate",+ "investment_focus": "Balanced approach, retirement planning"+ },+ LifecycleStage.SPENDING: {+ "typical_age_range": "60+",+ "primary_objective": InvestmentObjective.CURRENT_INCOME,+ "risk_tolerance": "Conservative to Moderate",+ "time_horizon": "Medium",+ "liquidity_needs": "High",+ "investment_focus": "Income generation, capital preservation"+ },+ LifecycleStage.GIFTING: {+ "typical_age_range": "65+",+ "primary_objective": InvestmentObjective.CAPITAL_APPRECIATION,+ "risk_tolerance": "Varies",+ "time_horizon": "Long (for beneficiaries)",+ "liquidity_needs": "Low",+ "investment_focus": "Growth for next generation, tax efficiency"+ }+ }++ stage_characteristics = lifecycle_characteristics[current_stage]++ # Customize based on individual circumstances+ customizations = {}++ # Age-based adjustments+ if current_stage == LifecycleStage.ACCUMULATION and age > 40:+ customizations["approaching_consolidation"] = True+ elif current_stage == LifecycleStage.CONSOLIDATION and age > 55:+ customizations["approaching_spending"] = True++ # Financial situation adjustments+ if financial_situation.get("wealth_level") == "high":+ customizations["higher_risk_capacity"] = True+ if financial_situation.get("income_stability") == "low":+ customizations["increased_liquidity_needs"] = True++ return {+ "current_stage": current_stage.value,+ "stage_characteristics": stage_characteristics,+ "customizations": customizations,+ "transition_considerations": cls._analyze_transition_needs(current_stage, age, financial_situation)+ }++ @classmethod+ def _analyze_transition_needs(cls, current_stage: LifecycleStage, age: int,+ financial_situation: Dict) -> Dict:+ """Analyze needs for transitioning between lifecycle stages"""+ transitions = {}++ if current_stage == LifecycleStage.ACCUMULATION:+ years_to_consolidation = max(0, 45 - age)+ transitions["to_consolidation"] = {+ "estimated_years": years_to_consolidation,+ "preparation_needed": years_to_consolidation <= 5,+ "key_actions": ["Increase savings rate", "Diversify investments", "Review risk tolerance"]+ }++ elif current_stage == LifecycleStage.CONSOLIDATION:+ years_to_spending = max(0, 65 - age)+ transitions["to_spending"] = {+ "estimated_years": years_to_spending,+ "preparation_needed": years_to_spending <= 10,+ "key_actions": ["Retirement planning", "Income replacement strategy", "Healthcare planning"]+ }++ return transitions++class PensionPlans:+ """Defined Contribution and Defined Benefit pension plan analysis"""++ @staticmethod+ def defined_contribution_analysis() -> Dict:+ """Analyze DC plan characteristics and investment implications"""+ return {+ "plan_structure": {+ "contribution_mechanism": "Employee and/or employer contributions to individual accounts",+ "investment_responsibility": "Participant bears investment risk and makes investment decisions",+ "benefit_determination": "Benefits based on account balance at retirement",+ "portability": "High - account follows employee"+ },+ "investment_characteristics": {+ "investment_options": "Typically limited menu of mutual funds",+ "asset_allocation_responsibility": "Participant responsibility",+ "lifecycle_funds": "Target-date funds increasingly popular",+ "default_options": "QDIA (Qualified Default Investment Alternative) required"+ },+ "risk_factors": {+ "investment_risk": "Borne entirely by participant",+ "longevity_risk": "Participant bears risk of outliving assets",+ "inflation_risk": "No automatic inflation protection",+ "timing_risk": "Market conditions at retirement impact benefits"+ },+ "advantages": [+ "Portable across employers",+ "Individual control over investments",+ "Potential for higher returns",+ "Transparent account values"+ ],+ "disadvantages": [+ "Investment risk on participant",+ "No guaranteed income",+ "Requires investment knowledge",+ "Vulnerable to market timing"+ ]+ }++ @staticmethod+ def defined_benefit_analysis() -> Dict:+ """Analyze DB plan characteristics and investment implications"""+ return {+ "plan_structure": {+ "benefit_formula": "Predetermined formula based on salary and service",+ "investment_responsibility": "Plan sponsor bears investment risk",+ "benefit_determination": "Formula-driven, typically lifetime annuity",+ "portability": "Limited - benefits tied to specific employer"+ },+ "investment_characteristics": {+ "asset_allocation": "Professional management by plan sponsor",+ "liability_driven_investing": "Assets managed to meet future liabilities",+ "sophisticated_strategies": "Access to alternative investments and advanced strategies",+ "actuarial_assumptions": "Investment returns assumed in actuarial valuations"+ },+ "risk_factors": {+ "sponsor_risk": "Plan dependent on employer's financial health",+ "underfunding_risk": "Plans may become underfunded",+ "regulatory_risk": "Subject to changing regulations",+ "interest_rate_risk": "Liability values sensitive to interest rate changes"+ },+ "advantages": [+ "Guaranteed retirement income",+ "Professional investment management",+ "Pooled longevity risk",+ "Inflation protection (some plans)"+ ],+ "disadvantages": [+ "Limited portability",+ "Dependent on employer viability",+ "Declining availability",+ "Complex regulations"+ ]+ }++ @staticmethod+ def compare_dc_vs_db(participant_profile: Dict) -> Dict:+ """Compare DC vs DB plans for specific participant profile"""+ age = participant_profile.get("age", 35)+ income = participant_profile.get("income", 50000)+ job_mobility = participant_profile.get("job_mobility", "moderate") # low, moderate, high+ investment_knowledge = participant_profile.get("investment_knowledge", "moderate")++ comparison = {+ "better_for_participant": None,+ "dc_advantages_for_this_profile": [],+ "db_advantages_for_this_profile": [],+ "recommendations": []+ }++ # Age considerations+ if age < 30:+ comparison["dc_advantages_for_this_profile"].append("Long time horizon allows for growth investing")+ comparison["dc_advantages_for_this_profile"].append("High portability valuable for career mobility")+ elif age > 50:+ comparison["db_advantages_for_this_profile"].append("Guaranteed income reduces late-career risk")+ comparison["db_advantages_for_this_profile"].append("Professional management valuable near retirement")++ # Job mobility considerations+ if job_mobility == "high":+ comparison["dc_advantages_for_this_profile"].append("Portability essential for mobile workers")+ elif job_mobility == "low":+ comparison["db_advantages_for_this_profile"].append("Long tenure maximizes DB benefits")++ # Investment knowledge considerations+ if investment_knowledge == "low":+ comparison["db_advantages_for_this_profile"].append("Professional management compensates for lack of knowledge")+ comparison["recommendations"].append("If DC only, consider target-date funds")+ elif investment_knowledge == "high":+ comparison["dc_advantages_for_this_profile"].append("Can potentially outperform through active management")++ # Determine recommendation+ dc_score = len(comparison["dc_advantages_for_this_profile"])+ db_score = len(comparison["db_advantages_for_this_profile"])++ if dc_score > db_score:+ comparison["better_for_participant"] = "DC Plan"+ elif db_score > dc_score:+ comparison["better_for_participant"] = "DB Plan"+ else:+ comparison["better_for_participant"] = "Both have merit"++ return comparison++class AssetManagementIndustry:+ """Asset management industry structure and characteristics"""++ @staticmethod+ def industry_overview() -> Dict:+ """Overview of asset management industry"""+ return {+ "industry_structure": {+ "key_participants": [+ "Investment management companies",+ "Banks and trust companies",+ "Insurance companies",+ "Brokerage firms",+ "Independent advisors"+ ],+ "market_segments": [+ "Institutional asset management",+ "Retail asset management",+ "High net worth management",+ "Alternative investments"+ ],+ "business_models": [+ "Fee-based management",+ "Performance-based fees",+ "Wrap fee programs",+ "Robo-advisors"+ ]+ },+ "industry_trends": {+ "fee_compression": "Ongoing pressure on management fees",+ "passive_investing_growth": "Continued growth in index funds and ETFs",+ "technology_adoption": "Robo-advisors and digital platforms",+ "regulatory_evolution": "Fiduciary standards and transparency requirements",+ "consolidation": "Industry consolidation through mergers and acquisitions"+ },+ "value_proposition": {+ "professional_management": "Expertise in investment analysis and portfolio construction",+ "diversification": "Access to broad range of investments",+ "economies_of_scale": "Lower costs through pooling",+ "administrative_services": "Record-keeping and reporting services"+ }+ }++ @staticmethod+ def fee_structures() -> Dict:+ """Analysis of asset management fee structures"""+ return {+ "management_fees": {+ "description": "Annual fee based on assets under management",+ "typical_ranges": {+ "equity_funds": "0.50% - 1.50%",+ "bond_funds": "0.25% - 1.00%",+ "index_funds": "0.05% - 0.25%",+ "alternative_funds": "1.00% - 2.00%"+ },+ "factors_affecting_fees": [+ "Asset class complexity",+ "Active vs passive management",+ "Fund size and scale",+ "Distribution channels"+ ]+ },+ "performance_fees": {+ "description": "Additional fees based on performance above benchmark",+ "typical_structure": "20% of excess returns above hurdle rate",+ "alignment_benefits": "Aligns manager interests with client outcomes",+ "potential_issues": "Can encourage excessive risk-taking"+ },+ "other_fees": {+ "transaction_costs": "Brokerage and trading costs",+ "administrative_fees": "Custody, record-keeping, and reporting",+ "distribution_fees": "12b-1 fees and sales charges",+ "redemption_fees": "Fees for early withdrawal from funds"+ }+ }++class MutualFunds:+ """Mutual funds and pooled investment products analysis"""++ @staticmethod+ def mutual_fund_structure() -> Dict:+ """Mutual fund structure and characteristics"""+ return {+ "legal_structure": {+ "investment_company": "Regulated under Investment Company Act of 1940",+ "board_of_directors": "Independent oversight of fund operations",+ "investment_advisor": "Manages portfolio and makes investment decisions",+ "fund_shareholders": "Own proportional interest in fund assets"+ },+ "operational_characteristics": {+ "daily_pricing": "NAV calculated daily after market close",+ "liquidity": "Shares redeemable daily at NAV",+ "professional_management": "Full-time portfolio management team",+ "diversification": "Broad diversification within asset class"+ },+ "types_of_funds": {+ "equity_funds": "Invest primarily in stocks",+ "bond_funds": "Invest primarily in fixed-income securities",+ "balanced_funds": "Mix of stocks and bonds",+ "sector_funds": "Focus on specific industry sectors",+ "international_funds": "Invest in foreign securities",+ "index_funds": "Passive replication of market indexes"+ }+ }++ @staticmethod+ def compare_pooled_products() -> Dict:+ """Compare mutual funds with other pooled investment products"""+ return {+ "mutual_funds": {+ "regulation": "Highly regulated under '40 Act",+ "liquidity": "Daily redemption at NAV",+ "transparency": "Daily NAV disclosure, quarterly holdings",+ "minimum_investment": "Typically low ($1,000 - $10,000)",+ "fees": "Management fee + operating expenses",+ "tax_efficiency": "Pass-through taxation, potential for distributions"+ },+ "etfs": {+ "regulation": "Regulated as investment companies or UITs",+ "liquidity": "Intraday trading on exchanges",+ "transparency": "Daily holdings disclosure",+ "minimum_investment": "Cost of one share",+ "fees": "Generally lower expense ratios",+ "tax_efficiency": "More tax efficient due to in-kind redemptions"+ },+ "hedge_funds": {+ "regulation": "Limited regulation, private placements",+ "liquidity": "Limited redemption windows",+ "transparency": "Limited disclosure to investors",+ "minimum_investment": "High ($1M+)",+ "fees": "2 and 20 fee structure typical",+ "tax_efficiency": "Various structures, often pass-through"+ },+ "private_equity": {+ "regulation": "Private placement exemptions",+ "liquidity": "Illiquid, long lock-up periods",+ "transparency": "Quarterly reporting to investors",+ "minimum_investment": "Very high ($5M+)",+ "fees": "Management fee + carried interest",+ "tax_efficiency": "Pass-through with potential tax advantages"+ },+ "unit_investment_trusts": {+ "regulation": "Regulated under '40 Act",+ "liquidity": "Redeemable units, but not actively traded",+ "transparency": "Fixed portfolio disclosed at inception",+ "minimum_investment": "Moderate ($1,000)",+ "fees": "Sales charge + annual fee",+ "tax_efficiency": "Pass-through taxation"+ }+ }++ @staticmethod+ def selection_criteria(investor_profile: InvestorProfile) -> Dict:+ """Provide selection criteria for pooled investment products"""+ recommendations = {+ "primary_recommendations": [],+ "considerations": [],+ "products_to_avoid": []+ }++ # Based on investor type+ if investor_profile.investor_type == InvestorType.INDIVIDUAL:+ if investor_profile.risk_tolerance == "conservative":+ recommendations["primary_recommendations"].extend([+ "Bond mutual funds",+ "Balanced funds",+ "Index funds"+ ])+ elif investor_profile.risk_tolerance == "aggressive":+ recommendations["primary_recommendations"].extend([+ "Equity mutual funds",+ "Sector ETFs",+ "International funds"+ ])++ # Based on liquidity needs+ if investor_profile.liquidity_needs > 0.2: # High liquidity needs+ recommendations["primary_recommendations"].append("Mutual funds and ETFs")+ recommendations["products_to_avoid"].extend([+ "Private equity",+ "Hedge funds with lock-ups"+ ])++ # Based on investment amount+ if hasattr(investor_profile, 'investment_amount'):+ if investor_profile.investment_amount < 100000:+ recommendations["products_to_avoid"].extend([+ "Hedge funds",+ "Private equity"+ ])++ return recommendations++class PortfolioManagement:+ """Main portfolio management interface"""++ def __init__(self):+ self.process = PortfolioManagementProcess()+ self.investor_classification = InvestorClassification()+ self.pension_analysis = PensionPlans()+ self.industry_analysis = AssetManagementIndustry()+ self.mutual_fund_analysis = MutualFunds()++ def comprehensive_portfolio_management_analysis(self, investor_profile: InvestorProfile) -> Dict:+ """Comprehensive portfolio management analysis"""+ return {+ "investor_analysis": {+ "investor_type": investor_profile.investor_type.value,+ "characteristics": self.investor_classification.get_investor_characteristics(investor_profile.investor_type),+ "lifecycle_analysis": self._lifecycle_analysis_if_individual(investor_profile)+ },+ "portfolio_process": {+ "planning": self.process.planning_step(investor_profile),+ "process_overview": self._get_process_overview()+ },+ "product_recommendations": {+ "pooled_products": self.mutual_fund_analysis.selection_criteria(investor_profile),+ "product_comparison": self.mutual_fund_analysis.compare_pooled_products()+ },+ "industry_context": {+ "industry_overview": self.industry_analysis.industry_overview(),+ "fee_analysis": self.industry_analysis.fee_structures()+ }+ }++ def _lifecycle_analysis_if_individual(self, investor_profile: InvestorProfile) -> Optional[Dict]:+ """Perform lifecycle analysis for individual investors"""+ if investor_profile.investor_type == InvestorType.INDIVIDUAL:+ # Estimate lifecycle stage based on available information+ if hasattr(investor_profile, 'age'):+ if investor_profile.age < 45:+ stage = LifecycleStage.ACCUMULATION+ elif investor_profile.age < 65:+ stage = LifecycleStage.CONSOLIDATION+ else:+ stage = LifecycleStage.SPENDING++ return self.investor_classification.lifecycle_analysis(+ stage, investor_profile.age, {"wealth_level": "moderate"}+ )+ return None++ def _get_process_overview(self) -> Dict:+ """Get overview of portfolio management process"""+ return {+ "process_steps": self.process.process_steps,+ "planning_substeps": self.process.planning_substeps,+ "continuous_nature": "Portfolio management is an ongoing, iterative process",+ "feedback_importance": "Regular monitoring and adjustment essential for success"+ }++ def pension_plan_analysis(self, plan_type: str, participant_profile: Dict) -> Dict:+ """Analyze pension plan characteristics and suitability"""+ if plan_type.lower() == "dc":+ plan_analysis = self.pension_analysis.defined_contribution_analysis()+ elif plan_type.lower() == "db":+ plan_analysis = self.pension_analysis.defined_benefit_analysis()+ else:+ # Compare both+ return {+ "dc_analysis": self.pension_analysis.defined_contribution_analysis(),+ "db_analysis": self.pension_analysis.defined_benefit_analysis(),+ "comparison": self.pension_analysis.compare_dc_vs_db(participant_profile)+ }++ return {+ "plan_analysis": plan_analysis,+ "suitability_for_participant": self._assess_plan_suitability(plan_type, participant_profile)+ }++ def _assess_plan_suitability(self, plan_type: str, participant_profile: Dict) -> Dict:+ """Assess pension plan suitability for specific participant"""+ age = participant_profile.get("age", 35)+ income = participant_profile.get("income", 50000)+ job_mobility = participant_profile.get("job_mobility", "moderate")++ suitability_score = 0+ factors = []++ if plan_type.lower() == "dc":+ # Factors favoring DC plans+ if age < 40:+ suitability_score += 20+ factors.append("Young age favors long-term growth potential")++ if job_mobility == "high":+ suitability_score += 25+ factors.append("High job mobility benefits from portability")++ if participant_profile.get("investment_knowledge", "moderate") == "high":+ suitability_score += 15+ factors.append("Investment knowledge enables active management")++ if income > 75000:+ suitability_score += 10+ factors.append("Higher income allows for greater contributions")++ elif plan_type.lower() == "db":+ # Factors favoring DB plans+ if age > 45:+ suitability_score += 20+ factors.append("Older age benefits from guaranteed income")++ if job_mobility == "low":+ suitability_score += 25+ factors.append("Low job mobility maximizes DB benefit accumulation")++ if participant_profile.get("risk_tolerance", "moderate") == "low":+ suitability_score += 20+ factors.append("Low risk tolerance suits guaranteed benefits")++ if participant_profile.get("investment_knowledge", "moderate") == "low":+ suitability_score += 15+ factors.append("Limited investment knowledge suits professional management")++ return {+ "suitability_score": min(100, suitability_score),+ "suitability_level": "High" if suitability_score > 70 else "Moderate" if suitability_score > 40 else "Low",+ "supporting_factors": factors,+ "recommendations": self._generate_pension_recommendations(plan_type, suitability_score, participant_profile)+ }++ def _generate_pension_recommendations(self, plan_type: str, suitability_score: int,+ participant_profile: Dict) -> List[str]:+ """Generate pension plan recommendations"""+ recommendations = []++ if plan_type.lower() == "dc":+ if suitability_score > 70:+ recommendations.append("DC plan well-suited - maximize contributions")+ recommendations.append("Consider aggressive growth allocation if young")+ recommendations.append("Take advantage of employer matching")+ elif suitability_score > 40:+ recommendations.append("DC plan suitable with careful planning")+ recommendations.append("Consider target-date funds for simplicity")+ recommendations.append("Regular portfolio rebalancing important")+ else:+ recommendations.append("DC plan challenges - seek professional guidance")+ recommendations.append("Focus on low-cost index funds")+ recommendations.append("Automate contributions and rebalancing")++ elif plan_type.lower() == "db":+ if suitability_score > 70:+ recommendations.append("DB plan excellent fit - maximize tenure")+ recommendations.append("Understand vesting schedule and benefit formula")+ recommendations.append("Consider supplemental retirement savings")+ elif suitability_score > 40:+ recommendations.append("DB plan provides good foundation")+ recommendations.append("Monitor plan funding status")+ recommendations.append("Diversify with additional retirement accounts")+ else:+ recommendations.append("DB plan may not meet all needs")+ recommendations.append("Supplement with portable retirement savings")+ recommendations.append("Consider career mobility implications")++ return recommendations++ # Helper methods for portfolio management process steps+ def _identify_secondary_objectives(self, profile: InvestorProfile) -> List[str]:+ """Identify secondary investment objectives"""+ secondary = []++ if profile.investment_objective != InvestmentObjective.CAPITAL_PRESERVATION:+ if profile.risk_tolerance == "conservative":+ secondary.append("Capital preservation")++ if profile.investment_objective != InvestmentObjective.CURRENT_INCOME:+ if profile.liquidity_needs > 0.3:+ secondary.append("Current income")++ if profile.investment_objective != InvestmentObjective.CAPITAL_APPRECIATION:+ if profile.time_horizon > 10:+ secondary.append("Capital appreciation")++ return secondary++ def _prioritize_objectives(self, profile: InvestorProfile) -> Dict[str, int]:+ """Prioritize investment objectives"""+ priorities = {+ profile.investment_objective.value: 1+ }++ secondary_objectives = self._identify_secondary_objectives(profile)+ for i, obj in enumerate(secondary_objectives, 2):+ priorities[obj] = i++ return priorities++ def _analyze_liquidity_needs(self, profile: InvestorProfile) -> Dict:+ """Analyze liquidity constraints"""+ return {+ "liquidity_requirement": profile.liquidity_needs,+ "liquidity_level": "High" if profile.liquidity_needs > 0.3 else+ "Moderate" if profile.liquidity_needs > 0.1 else "Low",+ "liquidity_sources": self._identify_liquidity_sources(profile),+ "emergency_fund_need": max(0.05, profile.liquidity_needs * 1.5)+ }++ def _analyze_time_horizon(self, profile: InvestorProfile) -> Dict:+ """Analyze time horizon constraints"""+ return {+ "time_horizon_years": profile.time_horizon,+ "horizon_category": "Long" if profile.time_horizon > 10 else+ "Medium" if profile.time_horizon > 5 else "Short",+ "investment_implications": self._time_horizon_implications(profile.time_horizon),+ "stage_transitions": self._identify_stage_transitions(profile)+ }++ def _analyze_tax_situation(self, profile: InvestorProfile) -> Dict:+ """Analyze tax considerations"""+ return {+ "tax_situation": profile.tax_situation,+ "tax_efficiency_importance": "High" if profile.tax_situation.get("marginal_rate", 0) > 0.25 else "Moderate",+ "tax_advantaged_accounts": self._recommend_tax_accounts(profile),+ "tax_loss_harvesting": profile.tax_situation.get("marginal_rate", 0) > 0.15+ }++ def _assess_risk_capacity_willingness(self, profile: InvestorProfile) -> Dict:+ """Assess risk capacity vs willingness"""+ # Simplified risk assessment+ capacity_factors = {+ "time_horizon": min(10, profile.time_horizon) / 10 * 30,+ "liquidity": (1 - profile.liquidity_needs) * 30,+ "income_stability": 20, # Would need actual data+ "wealth_level": 20 # Would need actual data+ }++ capacity_score = sum(capacity_factors.values())+ willingness_score = {"conservative": 25, "moderate": 50, "aggressive": 85}.get(profile.risk_tolerance, 50)++ return {+ "risk_capacity_score": capacity_score,+ "risk_willingness_score": willingness_score,+ "overall_risk_tolerance": min(capacity_score, willingness_score),+ "capacity_willingness_gap": abs(capacity_score - willingness_score),+ "constraining_factor": "Capacity" if capacity_score < willingness_score else "Willingness"+ }++ def _allocate_risk_budget(self, profile: InvestorProfile) -> Dict:+ """Allocate risk budget across portfolio"""+ risk_assessment = self._assess_risk_capacity_willingness(profile)+ total_risk_budget = risk_assessment["overall_risk_tolerance"]++ if profile.investment_objective == InvestmentObjective.CAPITAL_APPRECIATION:+ allocation = {"equity_risk": 0.7, "credit_risk": 0.2, "other_risk": 0.1}+ elif profile.investment_objective == InvestmentObjective.CURRENT_INCOME:+ allocation = {"credit_risk": 0.6, "equity_risk": 0.3, "other_risk": 0.1}+ else: # Total return or capital preservation+ allocation = {"equity_risk": 0.5, "credit_risk": 0.4, "other_risk": 0.1}++ return {+ "total_risk_budget": total_risk_budget,+ "risk_allocation": allocation,+ "risk_limits": {risk_type: total_risk_budget * weight+ for risk_type, weight in allocation.items()}+ }++ def _set_rebalancing_ranges(self, allocation: Dict[str, float]) -> Dict[str, Tuple[float, float]]:+ """Set rebalancing ranges for asset allocation"""+ ranges = {}+ for asset, weight in allocation.items():+ # Wider ranges for smaller allocations+ if weight < 0.1:+ range_width = 0.05+ elif weight < 0.3:+ range_width = 0.07+ else:+ range_width = 0.10++ lower_bound = max(0, weight - range_width)+ upper_bound = min(1, weight + range_width)+ ranges[asset] = (lower_bound, upper_bound)++ return ranges++ def _explain_allocation_rationale(self, profile: InvestorProfile, allocation: Dict[str, float]) -> Dict:+ """Explain rationale for asset allocation"""+ rationale = {+ "primary_drivers": [],+ "risk_considerations": [],+ "return_expectations": [],+ "constraints_addressed": []+ }++ # Primary drivers+ if profile.investment_objective == InvestmentObjective.CAPITAL_APPRECIATION:+ rationale["primary_drivers"].append("Growth-oriented allocation emphasizes equity exposure")+ elif profile.investment_objective == InvestmentObjective.CURRENT_INCOME:+ rationale["primary_drivers"].append("Income-focused allocation emphasizes fixed income")++ # Risk considerations+ if profile.risk_tolerance == "conservative":+ rationale["risk_considerations"].append("Conservative risk tolerance limits equity exposure")+ elif profile.risk_tolerance == "aggressive":+ rationale["risk_considerations"].append("Aggressive risk tolerance allows higher equity allocation")++ # Time horizon+ if profile.time_horizon > 10:+ rationale["return_expectations"].append("Long time horizon supports growth-oriented approach")+ elif profile.time_horizon < 5:+ rationale["return_expectations"].append("Short time horizon requires capital preservation focus")++ # Constraints+ if profile.liquidity_needs > 0.2:+ rationale["constraints_addressed"].append("High liquidity needs addressed through liquid asset allocation")++ return rationale++ def _calculate_expected_characteristics(self, allocation: Dict[str, float]) -> Dict:+ """Calculate expected portfolio characteristics"""+ # Simplified expected returns and risks by asset class+ asset_assumptions = {+ "domestic_equity": {"return": 0.10, "volatility": 0.18},+ "international_equity": {"return": 0.09, "volatility": 0.20},+ "domestic_bonds": {"return": 0.04, "volatility": 0.06},+ "international_bonds": {"return": 0.03, "volatility": 0.08},+ "real_estate": {"return": 0.08, "volatility": 0.15},+ "alternatives": {"return": 0.12, "volatility": 0.25},+ "private_equity": {"return": 0.14, "volatility": 0.30},+ "hedge_funds": {"return": 0.08, "volatility": 0.12},+ "cash": {"return": 0.02, "volatility": 0.01}+ }++ expected_return = 0+ weighted_variance = 0++ for asset, weight in allocation.items():+ if asset in asset_assumptions:+ assumptions = asset_assumptions[asset]+ expected_return += weight * assumptions["return"]+ weighted_variance += (weight * assumptions["volatility"]) ** 2++ # Simplified calculation (assumes zero correlation)+ expected_volatility = np.sqrt(weighted_variance)++ return {+ "expected_annual_return": expected_return,+ "expected_volatility": expected_volatility,+ "expected_sharpe_ratio": (expected_return - 0.03) / expected_volatility if expected_volatility > 0 else 0,+ "risk_return_profile": self._classify_risk_return_profile(expected_return, expected_volatility)+ }++ def _classify_risk_return_profile(self, expected_return: float, expected_volatility: float) -> str:+ """Classify portfolio risk-return profile"""+ if expected_return > 0.08 and expected_volatility > 0.15:+ return "Aggressive Growth"+ elif expected_return > 0.06 and expected_volatility > 0.10:+ return "Moderate Growth"+ elif expected_return > 0.04 and expected_volatility < 0.10:+ return "Conservative Growth"+ elif expected_return < 0.04:+ return "Capital Preservation"+ else:+ return "Balanced"++ # Additional helper methods+ def _identify_liquidity_sources(self, profile: InvestorProfile) -> List[str]:+ """Identify potential liquidity sources"""+ sources = ["Cash and cash equivalents"]++ if profile.liquidity_needs > 0.2:+ sources.extend(["Short-term bond funds", "Money market funds"])++ if profile.time_horizon > 5:+ sources.append("Systematic withdrawal from equity funds")++ return sources++ def _time_horizon_implications(self, time_horizon: int) -> Dict:+ """Analyze investment implications of time horizon"""+ if time_horizon > 10:+ return {+ "asset_allocation": "Can emphasize growth assets",+ "risk_tolerance": "Can accept higher volatility",+ "rebalancing": "Less frequent rebalancing needed",+ "tax_efficiency": "Focus on long-term capital gains"+ }+ elif time_horizon > 5:+ return {+ "asset_allocation": "Balanced approach appropriate",+ "risk_tolerance": "Moderate risk acceptable",+ "rebalancing": "Regular rebalancing important",+ "tax_efficiency": "Consider tax-loss harvesting"+ }+ else:+ return {+ "asset_allocation": "Emphasize capital preservation",+ "risk_tolerance": "Low risk tolerance appropriate",+ "rebalancing": "Frequent monitoring needed",+ "tax_efficiency": "Focus on current income"+ }++ def _identify_stage_transitions(self, profile: InvestorProfile) -> List[str]:+ """Identify upcoming lifecycle stage transitions"""+ transitions = []++ if hasattr(profile, 'age'):+ if 40 <= profile.age <= 50:+ transitions.append("Approaching peak earning years")+ elif 50 <= profile.age <= 60:+ transitions.append("Pre-retirement planning phase")+ elif profile.age > 60:+ transitions.append("Retirement transition")++ return transitions++ def _recommend_tax_accounts(self, profile: InvestorProfile) -> List[str]:+ """Recommend tax-advantaged account types"""+ recommendations = []++ marginal_rate = profile.tax_situation.get("marginal_rate", 0.22)++ if marginal_rate > 0.20:+ recommendations.append("Traditional 401(k) or IRA for current deduction")++ if profile.time_horizon > 10:+ recommendations.append("Roth IRA for tax-free growth")++ if profile.investor_type == InvestorType.INDIVIDUAL:+ recommendations.append("Health Savings Account if eligible")++ return recommendations++ # Portfolio management process helper methods+ def _make_allocation_decisions(self, allocation_targets: Dict) -> Dict:+ """Make tactical allocation decisions"""+ return {+ "strategic_allocation": allocation_targets,+ "tactical_adjustments": "Based on current market conditions",+ "implementation_approach": "Systematic approach to reaching targets",+ "timing_considerations": "Dollar-cost averaging for large allocations"+ }++ def _security_selection_process(self, allocation_targets: Dict) -> Dict:+ """Define security selection process"""+ return {+ "selection_criteria": [+ "Cost efficiency (low expense ratios)",+ "Tracking error minimization for passive funds",+ "Manager tenure and consistency for active funds",+ "Tax efficiency considerations"+ ],+ "due_diligence_process": [+ "Quantitative screening",+ "Qualitative assessment",+ "Risk analysis",+ "Performance attribution"+ ]+ }++ def _implementation_strategy(self, market_conditions: Dict) -> Dict:+ """Define implementation strategy"""+ return {+ "implementation_approach": "Gradual implementation to minimize market impact",+ "cost_management": "Focus on minimizing transaction costs",+ "market_timing": "Avoid market timing, focus on systematic approach",+ "liquidity_management": "Ensure adequate liquidity throughout process"+ }++ def _trading_considerations(self) -> Dict:+ """Define trading considerations"""+ return {+ "execution_priorities": ["Cost minimization", "Market impact reduction", "Speed of execution"],+ "order_types": "Use of limit orders and volume-weighted average price (VWAP)",+ "timing": "Trade during high-liquidity periods when possible",+ "monitoring": "Real-time monitoring of execution quality"+ }++ def _measure_performance(self, portfolio_performance: Dict, benchmarks: Dict) -> Dict:+ """Measure portfolio performance"""+ return {+ "absolute_performance": portfolio_performance.get("total_return", 0),+ "relative_performance": "Performance vs. appropriate benchmarks",+ "risk_adjusted_performance": "Sharpe ratio and other risk-adjusted metrics",+ "attribution_analysis": "Performance attribution by asset class and security selection"+ }++ def _evaluate_performance(self, portfolio_performance: Dict) -> Dict:+ """Evaluate portfolio performance"""+ return {+ "performance_evaluation": "Assessment of returns relative to objectives",+ "risk_evaluation": "Analysis of risk taken relative to risk budget",+ "consistency_evaluation": "Evaluation of performance consistency over time",+ "benchmark_comparison": "Comparison to relevant benchmarks and peer groups"+ }++ def _monitor_portfolio(self) -> Dict:+ """Define portfolio monitoring approach"""+ return {+ "monitoring_frequency": "Continuous monitoring with formal reviews quarterly",+ "key_metrics": ["Asset allocation drift", "Performance vs. benchmarks", "Risk metrics"],+ "alert_systems": "Automated alerts for significant deviations",+ "reporting": "Regular reporting to stakeholders"+ }++ def _assess_rebalancing_needs(self, portfolio_performance: Dict) -> Dict:+ """Assess portfolio rebalancing needs"""+ return {+ "rebalancing_triggers": [+ "Asset allocation drift beyond tolerance bands",+ "Significant market movements",+ "Changes in client circumstances",+ "Calendar-based rebalancing"+ ],+ "rebalancing_approach": "Systematic approach based on predefined rules",+ "cost_benefit_analysis": "Consider transaction costs vs. rebalancing benefits",+ "tax_implications": "Consider tax consequences of rebalancing transactions"+ }\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_planning.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_planning.pynew file mode 100644index 000000000..1afa527ed--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/portfolio_planning.py@@ -0,0 +1,1565 @@++Portfolio Portfolio Planning Module+===============================++Portfolio planning and strategy development++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple+from dataclasses import dataclass, field+from datetime import datetime, timedelta+from enum import Enum++from config import AssetClass, MathConstants+from portfolio_management import InvestorType, InvestmentObjective, InvestorProfile++class ConstraintType(Enum):+ """Types of investment constraints"""+ LIQUIDITY = "liquidity"+ TIME_HORIZON = "time_horizon"+ TAX = "tax"+ LEGAL_REGULATORY = "legal_regulatory"+ UNIQUE_CIRCUMSTANCES = "unique_circumstances"++class ESGApproach(Enum):+ """ESG integration approaches"""+ EXCLUSIONARY = "exclusionary"+ BEST_IN_CLASS = "best_in_class"+ THEMATIC = "thematic"+ INTEGRATION = "integration"+ IMPACT = "impact"+ SHAREHOLDER_ENGAGEMENT = "shareholder_engagement"++@dataclass+class InvestmentPolicyStatement:+ """Investment Policy Statement structure"""+ client_information: Dict+ investment_objectives: Dict+ investment_constraints: Dict+ investment_guidelines: Dict+ strategic_asset_allocation: Dict+ rebalancing_policy: Dict+ performance_measurement: Dict+ responsibilities: Dict+ review_schedule: Dict+ esg_policy: Optional[Dict] = None+ creation_date: datetime = field(default_factory=datetime.now)+ last_review_date: Optional[datetime] = None++class IPSFramework:+ """Investment Policy Statement framework and construction"""++ @staticmethod+ def create_ips_template() -> Dict:+ """Create comprehensive IPS template"""+ return {+ "executive_summary": {+ "purpose": "Define investment objectives, constraints, and guidelines",+ "scope": "Applies to all investment assets under management",+ "governance": "Oversight and decision-making framework"+ },+ "client_information": {+ "client_type": "Individual/Institutional",+ "contact_information": {},+ "background": "Client history and context",+ "financial_situation": "Current financial position"+ },+ "investment_objectives": {+ "return_objectives": {+ "primary_objective": None,+ "target_return": None,+ "return_requirements": [],+ "benchmark": None+ },+ "risk_objectives": {+ "risk_tolerance": None,+ "risk_capacity": None,+ "risk_constraints": [],+ "maximum_acceptable_loss": None+ }+ },+ "investment_constraints": {+ "liquidity": {+ "liquidity_requirements": None,+ "emergency_fund": None,+ "cash_flow_needs": []+ },+ "time_horizon": {+ "investment_horizon": None,+ "sub_periods": [],+ "horizon_changes": []+ },+ "tax": {+ "tax_status": None,+ "tax_concerns": [],+ "tax_optimization": []+ },+ "legal_regulatory": {+ "applicable_regulations": [],+ "compliance_requirements": [],+ "prohibited_investments": []+ },+ "unique_circumstances": {+ "special_considerations": [],+ "preferences": [],+ "restrictions": []+ }+ },+ "investment_guidelines": {+ "asset_allocation": {},+ "security_selection": {},+ "portfolio_construction": {},+ "risk_management": {}+ },+ "performance_measurement": {+ "benchmarks": [],+ "evaluation_criteria": [],+ "reporting_frequency": None+ },+ "responsibilities": {+ "client_responsibilities": [],+ "advisor_responsibilities": [],+ "third_party_responsibilities": []+ },+ "review_and_monitoring": {+ "review_frequency": None,+ "review_triggers": [],+ "update_procedures": []+ }+ }++ @staticmethod+ def validate_ips(ips: InvestmentPolicyStatement) -> Dict:+ """Validate IPS completeness and consistency"""+ validation_results = {+ "is_valid": True,+ "errors": [],+ "warnings": [],+ "completeness_score": 0+ }++ # Check required sections+ required_sections = [+ "investment_objectives", "investment_constraints",+ "strategic_asset_allocation", "performance_measurement"+ ]++ for section in required_sections:+ if not hasattr(ips, section) or not getattr(ips, section):+ validation_results["errors"].append(f"Missing required section: {section}")+ validation_results["is_valid"] = False++ # Check objective-constraint consistency+ if hasattr(ips, 'investment_objectives') and hasattr(ips, 'investment_constraints'):+ consistency_check = IPSFramework._check_objective_constraint_consistency(+ ips.investment_objectives, ips.investment_constraints+ )+ validation_results["warnings"].extend(consistency_check)++ # Calculate completeness score+ validation_results["completeness_score"] = IPSFramework._calculate_completeness_score(ips)++ return validation_results++ @staticmethod+ def _check_objective_constraint_consistency(objectives: Dict, constraints: Dict) -> List[str]:+ """Check consistency between objectives and constraints"""+ warnings = []++ # Check return-risk consistency+ if objectives.get("return_objectives", {}).get("target_return", 0) > 0.10:+ if constraints.get("time_horizon", {}).get("investment_horizon", 10) < 5:+ warnings.append("High return target inconsistent with short time horizon")++ # Check liquidity-return consistency+ if constraints.get("liquidity", {}).get("liquidity_requirements", 0) > 0.3:+ if objectives.get("return_objectives", {}).get("target_return", 0) > 0.08:+ warnings.append("High liquidity needs may conflict with return objectives")++ return warnings++ @staticmethod+ def _calculate_completeness_score(ips: InvestmentPolicyStatement) -> float:+ """Calculate IPS completeness score"""+ sections = [+ 'client_information', 'investment_objectives', 'investment_constraints',+ 'investment_guidelines', 'strategic_asset_allocation', 'rebalancing_policy',+ 'performance_measurement', 'responsibilities', 'review_schedule'+ ]++ completed_sections = sum(1 for section in sections+ if hasattr(ips, section) and getattr(ips, section))++ return (completed_sections / len(sections)) * 100++class ObjectivesFramework:+ """Investment objectives framework and analysis"""++ @staticmethod+ def analyze_return_objectives(client_profile: InvestorProfile,+ financial_data: Dict) -> Dict:+ """Analyze and set return objectives"""++ # Calculate required return based on goals+ required_return = ObjectivesFramework._calculate_required_return(+ client_profile, financial_data+ )++ # Assess return expectations+ return_expectations = ObjectivesFramework._assess_return_expectations(+ client_profile+ )++ # Set return targets+ return_targets = ObjectivesFramework._set_return_targets(+ required_return, return_expectations, client_profile+ )++ return {+ "required_return": required_return,+ "return_expectations": return_expectations,+ "return_targets": return_targets,+ "return_constraints": ObjectivesFramework._identify_return_constraints(client_profile),+ "benchmark_selection": ObjectivesFramework._select_benchmarks(client_profile)+ }++ @staticmethod+ def analyze_risk_objectives(client_profile: InvestorProfile,+ return_objectives: Dict) -> Dict:+ """Analyze and set risk objectives"""++ # Assess risk capacity+ risk_capacity = ObjectivesFramework._assess_risk_capacity(client_profile)++ # Assess risk willingness+ risk_willingness = ObjectivesFramework._assess_risk_willingness(client_profile)++ # Reconcile capacity and willingness+ risk_tolerance = ObjectivesFramework._reconcile_risk_tolerance(+ risk_capacity, risk_willingness+ )++ # Set risk constraints+ risk_constraints = ObjectivesFramework._set_risk_constraints(+ risk_tolerance, return_objectives+ )++ return {+ "risk_capacity": risk_capacity,+ "risk_willingness": risk_willingness,+ "overall_risk_tolerance": risk_tolerance,+ "risk_constraints": risk_constraints,+ "risk_metrics": ObjectivesFramework._define_risk_metrics(risk_tolerance)+ }++ @staticmethod+ def _calculate_required_return(client_profile: InvestorProfile,+ financial_data: Dict) -> Dict:+ """Calculate required return to meet objectives"""+ current_assets = financial_data.get("current_portfolio_value", 0)+ future_goals = financial_data.get("financial_goals", [])+ annual_contributions = financial_data.get("annual_contributions", 0)++ required_returns = {}++ for goal in future_goals:+ goal_value = goal.get("target_value", 0)+ years_to_goal = goal.get("years_to_goal", 10)++ if current_assets > 0 and years_to_goal > 0:+ # Calculate required return using future value formula+ # FV = PV * (1 + r)^n + PMT * [((1 + r)^n - 1) / r]+ # Solve for r numerically (simplified approach)++ for test_rate in np.arange(0.01, 0.20, 0.001):+ future_value = (current_assets * (1 + test_rate) ** years_to_goal ++ annual_contributions * (((1 + test_rate) ** years_to_goal - 1) / test_rate))++ if future_value >= goal_value:+ required_returns[goal.get("name", "goal")] = test_rate+ break++ return {+ "goal_specific_returns": required_returns,+ "overall_required_return": max(required_returns.values()) if required_returns else 0.07,+ "feasibility_assessment": ObjectivesFramework._assess_return_feasibility(required_returns)+ }++ @staticmethod+ def _assess_return_expectations(client_profile: InvestorProfile) -> Dict:+ """Assess realistic return expectations"""+ # Market-based return expectations by asset class+ market_returns = {+ "cash": 0.02,+ "bonds": 0.04,+ "domestic_equity": 0.09,+ "international_equity": 0.08,+ "real_estate": 0.07,+ "alternatives": 0.10+ }++ # Adjust based on economic environment+ economic_adjustment = 0.0 # Would be based on current conditions++ adjusted_returns = {asset: ret + economic_adjustment+ for asset, ret in market_returns.items()}++ return {+ "market_based_expectations": adjusted_returns,+ "portfolio_expected_return_range": (0.04, 0.12),+ "risk_adjusted_expectations": ObjectivesFramework._risk_adjust_returns(+ adjusted_returns, client_profile.risk_tolerance+ )+ }++ @staticmethod+ def _set_return_targets(required_return: Dict, expectations: Dict,+ client_profile: InvestorProfile) -> Dict:+ """Set appropriate return targets"""+ overall_required = required_return.get("overall_required_return", 0.07)+ market_expectation = expectations.get("portfolio_expected_return_range", (0.04, 0.12))++ # Conservative approach: use lower of required and achievable+ if overall_required > market_expectation[1]:+ target_return = market_expectation[1]+ achievability = "Challenging - may require revision of goals"+ elif overall_required < market_expectation[0]:+ target_return = market_expectation[0]+ achievability = "Conservative - goals likely achievable"+ else:+ target_return = overall_required+ achievability = "Reasonable - goals achievable with appropriate risk"++ return {+ "primary_return_target": target_return,+ "return_range": (target_return * 0.8, target_return * 1.2),+ "achievability_assessment": achievability,+ "downside_protection": client_profile.risk_tolerance == "conservative"+ }++ @staticmethod+ def _assess_risk_capacity(client_profile: InvestorProfile) -> Dict:+ """Assess quantitative risk capacity"""+ capacity_factors = {+ "time_horizon": min(1.0, client_profile.time_horizon / 20),+ "liquidity_needs": 1 - client_profile.liquidity_needs,+ "income_stability": 0.8, # Would be based on actual data+ "wealth_level": 0.7 # Would be based on actual data+ }++ overall_capacity = np.mean(list(capacity_factors.values()))++ return {+ "capacity_score": overall_capacity * 100,+ "capacity_level": "High" if overall_capacity > 0.75 else+ "Moderate" if overall_capacity > 0.5 else "Low",+ "capacity_factors": capacity_factors,+ "limiting_factors": [factor for factor, score in capacity_factors.items()+ if score < 0.5]+ }++ @staticmethod+ def _assess_risk_willingness(client_profile: InvestorProfile) -> Dict:+ """Assess behavioral risk willingness"""+ willingness_map = {+ "conservative": 30,+ "moderate": 60,+ "aggressive": 90+ }++ willingness_score = willingness_map.get(client_profile.risk_tolerance, 60)++ return {+ "willingness_score": willingness_score,+ "willingness_level": client_profile.risk_tolerance,+ "behavioral_factors": ObjectivesFramework._identify_behavioral_factors(client_profile),+ "education_needs": willingness_score < 40+ }++ @staticmethod+ def _reconcile_risk_tolerance(capacity: Dict, willingness: Dict) -> Dict:+ """Reconcile risk capacity and willingness"""+ capacity_score = capacity["capacity_score"]+ willingness_score = willingness["willingness_score"]++ # Use more conservative of the two+ overall_tolerance = min(capacity_score, willingness_score)++ mismatch = abs(capacity_score - willingness_score)+ significant_mismatch = mismatch > 30++ return {+ "overall_risk_tolerance": overall_tolerance,+ "risk_level": "High" if overall_tolerance > 75 else+ "Moderate" if overall_tolerance > 50 else "Low",+ "capacity_willingness_gap": mismatch,+ "significant_mismatch": significant_mismatch,+ "constraining_factor": "Capacity" if capacity_score < willingness_score else "Willingness",+ "reconciliation_approach": ObjectivesFramework._recommend_reconciliation_approach(+ capacity_score, willingness_score, significant_mismatch+ )+ }++class ConstraintsAnalysis:+ """Investment constraints analysis and management"""++ @staticmethod+ def analyze_liquidity_constraints(client_profile: InvestorProfile,+ cash_flow_data: Dict) -> Dict:+ """Analyze liquidity requirements and constraints"""++ # Calculate liquidity needs+ liquidity_needs = ConstraintsAnalysis._calculate_liquidity_needs(+ client_profile, cash_flow_data+ )++ # Assess liquidity sources+ liquidity_sources = ConstraintsAnalysis._assess_liquidity_sources(+ cash_flow_data+ )++ # Set liquidity constraints+ liquidity_constraints = ConstraintsAnalysis._set_liquidity_constraints(+ liquidity_needs, liquidity_sources+ )++ return {+ "liquidity_needs": liquidity_needs,+ "liquidity_sources": liquidity_sources,+ "liquidity_constraints": liquidity_constraints,+ "emergency_fund_requirement": ConstraintsAnalysis._calculate_emergency_fund(+ client_profile, cash_flow_data+ )+ }++ @staticmethod+ def analyze_time_horizon_constraints(client_profile: InvestorProfile) -> Dict:+ """Analyze time horizon constraints"""++ primary_horizon = client_profile.time_horizon++ # Identify sub-periods+ sub_periods = ConstraintsAnalysis._identify_sub_periods(client_profile)++ # Asset allocation implications+ allocation_implications = ConstraintsAnalysis._time_horizon_allocation_implications(+ primary_horizon, sub_periods+ )++ return {+ "primary_time_horizon": primary_horizon,+ "horizon_category": "Long" if primary_horizon > 10 else+ "Medium" if primary_horizon > 5 else "Short",+ "sub_periods": sub_periods,+ "allocation_implications": allocation_implications,+ "glide_path_considerations": ConstraintsAnalysis._assess_glide_path_needs(+ primary_horizon, sub_periods+ )+ }++ @staticmethod+ def analyze_tax_constraints(client_profile: InvestorProfile) -> Dict:+ """Analyze tax considerations and constraints"""++ tax_situation = client_profile.tax_situation++ # Tax efficiency strategies+ tax_strategies = ConstraintsAnalysis._identify_tax_strategies(tax_situation)++ # Account type recommendations+ account_recommendations = ConstraintsAnalysis._recommend_account_types(+ tax_situation, client_profile+ )++ # Asset location strategy+ asset_location = ConstraintsAnalysis._develop_asset_location_strategy(+ tax_situation+ )++ return {+ "tax_situation_analysis": tax_situation,+ "tax_efficiency_strategies": tax_strategies,+ "account_recommendations": account_recommendations,+ "asset_location_strategy": asset_location,+ "tax_loss_harvesting": ConstraintsAnalysis._assess_tax_loss_harvesting(tax_situation)+ }++ @staticmethod+ def analyze_legal_regulatory_constraints(client_profile: InvestorProfile) -> Dict:+ """Analyze legal and regulatory constraints"""++ applicable_regulations = ConstraintsAnalysis._identify_applicable_regulations(+ client_profile+ )++ compliance_requirements = ConstraintsAnalysis._assess_compliance_requirements(+ applicable_regulations, client_profile+ )++ prohibited_investments = ConstraintsAnalysis._identify_prohibited_investments(+ applicable_regulations, client_profile+ )++ return {+ "applicable_regulations": applicable_regulations,+ "compliance_requirements": compliance_requirements,+ "prohibited_investments": prohibited_investments,+ "reporting_obligations": ConstraintsAnalysis._identify_reporting_obligations(+ applicable_regulations+ )+ }++ @staticmethod+ def _calculate_liquidity_needs(client_profile: InvestorProfile,+ cash_flow_data: Dict) -> Dict:+ """Calculate specific liquidity needs"""+ annual_expenses = cash_flow_data.get("annual_expenses", 50000)+ irregular_expenses = cash_flow_data.get("irregular_expenses", [])++ # Emergency fund need+ emergency_fund = annual_expenses * 0.5 # 6 months expenses++ # Planned expenses+ planned_expenses = sum(expense.get("amount", 0) for expense in irregular_expenses)++ # Total liquidity need+ total_liquidity = emergency_fund + planned_expenses++ return {+ "emergency_fund_need": emergency_fund,+ "planned_expenses": planned_expenses,+ "total_liquidity_need": total_liquidity,+ "liquidity_percentage": client_profile.liquidity_needs,+ "liquidity_timeline": ConstraintsAnalysis._create_liquidity_timeline(irregular_expenses)+ }++ @staticmethod+ def _identify_sub_periods(client_profile: InvestorProfile) -> List[Dict]:+ """Identify investment sub-periods with different characteristics"""+ sub_periods = []++ if client_profile.investor_type == InvestorType.INDIVIDUAL:+ if hasattr(client_profile, 'age'):+ age = client_profile.age++ if age < 45:+ sub_periods.append({+ "period": "Accumulation phase",+ "years": max(1, 45 - age),+ "characteristics": "High risk tolerance, growth focus"+ })++ if 45 <= age < 65:+ sub_periods.append({+ "period": "Consolidation phase",+ "years": max(1, 65 - age),+ "characteristics": "Moderate risk, balanced approach"+ })++ if age >= 55:+ sub_periods.append({+ "period": "Pre-retirement",+ "years": max(1, 65 - age),+ "characteristics": "Risk reduction, income focus"+ })++ return sub_periods++class AssetAllocationFramework:+ """Asset allocation specification and framework"""++ @staticmethod+ def define_asset_classes(investment_universe: Optional[List[str]] = None) -> Dict:+ """Define and specify asset classes for allocation"""++ if investment_universe is None:+ investment_universe = ["domestic_equity", "international_equity",+ "domestic_bonds", "international_bonds",+ "real_estate", "commodities", "cash"]++ asset_class_definitions = {}++ for asset_class in investment_universe:+ asset_class_definitions[asset_class] = AssetAllocationFramework._get_asset_class_definition(+ asset_class+ )++ return {+ "asset_classes": asset_class_definitions,+ "correlation_structure": AssetAllocationFramework._estimate_correlation_structure(+ investment_universe+ ),+ "expected_returns": AssetAllocationFramework._estimate_expected_returns(+ investment_universe+ ),+ "risk_characteristics": AssetAllocationFramework._estimate_risk_characteristics(+ investment_universe+ )+ }++ @staticmethod+ def strategic_asset_allocation(client_profile: InvestorProfile,+ objectives: Dict,+ constraints: Dict,+ asset_classes: Dict) -> Dict:+ """Develop strategic asset allocation"""++ # Base allocation by investor type and objectives+ base_allocation = AssetAllocationFramework._get_base_allocation(+ client_profile, objectives+ )++ # Adjust for constraints+ constrained_allocation = AssetAllocationFramework._adjust_for_constraints(+ base_allocation, constraints+ )++ # Optimize allocation+ optimized_allocation = AssetAllocationFramework._optimize_allocation(+ constrained_allocation, asset_classes, objectives+ )++ # Set rebalancing bands+ rebalancing_bands = AssetAllocationFramework._set_rebalancing_bands(+ optimized_allocation+ )++ return {+ "strategic_allocation": optimized_allocation,+ "rebalancing_bands": rebalancing_bands,+ "allocation_rationale": AssetAllocationFramework._explain_allocation_rationale(+ client_profile, objectives, constraints, optimized_allocation+ ),+ "expected_portfolio_characteristics": AssetAllocationFramework._calculate_portfolio_characteristics(+ optimized_allocation, asset_classes+ )+ }++ @staticmethod+ def _get_asset_class_definition(asset_class: str) -> Dict:+ """Get detailed asset class definition"""+ definitions = {+ "domestic_equity": {+ "description": "Domestic equity securities",+ "risk_level": "High",+ "expected_return": 0.09,+ "volatility": 0.18,+ "liquidity": "High",+ "inflation_hedge": "Good"+ },+ "international_equity": {+ "description": "International developed market equity",+ "risk_level": "High",+ "expected_return": 0.08,+ "volatility": 0.20,+ "liquidity": "High",+ "inflation_hedge": "Good"+ },+ "domestic_bonds": {+ "description": "Domestic investment grade bonds",+ "risk_level": "Low to Moderate",+ "expected_return": 0.04,+ "volatility": 0.06,+ "liquidity": "High",+ "inflation_hedge": "Poor"+ },+ "real_estate": {+ "description": "Real estate investment trusts",+ "risk_level": "Moderate",+ "expected_return": 0.07,+ "volatility": 0.15,+ "liquidity": "Moderate",+ "inflation_hedge": "Good"+ },+ "commodities": {+ "description": "Commodity futures and ETFs",+ "risk_level": "High",+ "expected_return": 0.05,+ "volatility": 0.25,+ "liquidity": "Moderate",+ "inflation_hedge": "Excellent"+ },+ "cash": {+ "description": "Cash and cash equivalents",+ "risk_level": "Very Low",+ "expected_return": 0.02,+ "volatility": 0.01,+ "liquidity": "Very High",+ "inflation_hedge": "Poor"+ }+ }++ return definitions.get(asset_class, {})++ @staticmethod+ def _get_base_allocation(client_profile: InvestorProfile, objectives: Dict) -> Dict:+ """Get base asset allocation"""++ if client_profile.investment_objective == InvestmentObjective.CAPITAL_APPRECIATION:+ if client_profile.risk_tolerance == "aggressive":+ return {+ "domestic_equity": 0.50,+ "international_equity": 0.30,+ "domestic_bonds": 0.15,+ "cash": 0.05+ }+ else:+ return {+ "domestic_equity": 0.40,+ "international_equity": 0.20,+ "domestic_bonds": 0.30,+ "real_estate": 0.05,+ "cash": 0.05+ }++ elif client_profile.investment_objective == InvestmentObjective.CURRENT_INCOME:+ return {+ "domestic_bonds": 0.50,+ "domestic_equity": 0.25,+ "real_estate": 0.15,+ "cash": 0.10+ }++ else: # Total return or balanced+ return {+ "domestic_equity": 0.35,+ "international_equity": 0.15,+ "domestic_bonds": 0.35,+ "real_estate": 0.10,+ "cash": 0.05+ }++class PortfolioConstructionPrinciples:+ """Portfolio construction principles and guidelines"""++ @staticmethod+ def construction_framework() -> Dict:+ """Define portfolio construction framework"""+ return {+ "core_principles": {+ "diversification": "Spread risk across multiple asset classes and securities",+ "cost_efficiency": "Minimize fees and transaction costs",+ "tax_efficiency": "Consider tax implications in all decisions",+ "liquidity_management": "Maintain appropriate liquidity levels",+ "risk_control": "Monitor and control portfolio risk exposures"+ },+ "construction_process": {+ "strategic_allocation": "Set long-term asset class targets",+ "tactical_allocation": "Make short-term adjustments based on market conditions",+ "security_selection": "Choose specific securities within asset classes",+ "implementation": "Execute portfolio construction efficiently",+ "monitoring": "Continuously monitor and rebalance"+ },+ "portfolio_structure": {+ "core_holdings": "Large, stable positions in broad market exposures",+ "satellite_holdings": "Smaller, specialized positions for enhancement",+ "cash_management": "Efficient cash management and transition planning"+ }+ }++ @staticmethod+ def risk_budgeting_approach(total_risk_budget: float,+ asset_allocation: Dict) -> Dict:+ """Implement risk budgeting approach to portfolio construction"""++ # Estimate risk contributions by asset class+ risk_contributions = PortfolioConstructionPrinciples._estimate_risk_contributions(+ asset_allocation+ )++ # Allocate risk budget+ risk_allocations = {}+ for asset_class, contribution in risk_contributions.items():+ risk_allocations[asset_class] = total_risk_budget * contribution++ return {+ "total_risk_budget": total_risk_budget,+ "risk_contributions": risk_contributions,+ "risk_allocations": risk_allocations,+ "diversification_benefit": PortfolioConstructionPrinciples._calculate_diversification_benefit(+ asset_allocation, risk_contributions+ )+ }++ @staticmethod+ def _estimate_risk_contributions(asset_allocation: Dict) -> Dict:+ """Estimate risk contributions by asset class"""+ # Simplified risk contribution estimation+ risk_weights = {+ "domestic_equity": 0.18,+ "international_equity": 0.20,+ "domestic_bonds": 0.06,+ "international_bonds": 0.08,+ "real_estate": 0.15,+ "commodities": 0.25,+ "cash": 0.01+ }++ contributions = {}+ total_risk = 0++ # Calculate weighted risk+ for asset_class, weight in asset_allocation.items():+ if asset_class in risk_weights:+ risk_contribution = weight * risk_weights[asset_class]+ contributions[asset_class] = risk_contribution+ total_risk += risk_contribution++ # Normalize to sum to 1+ if total_risk > 0:+ contributions = {k: v / total_risk for k, v in contributions.items()}++ return contributions++class ESGIntegration:+ """Environmental, Social, and Governance integration framework"""++ @staticmethod+ def esg_integration_approaches() -> Dict:+ """Define ESG integration approaches"""+ return {+ ESGApproach.EXCLUSIONARY.value: {+ "description": "Exclude investments based on ESG criteria",+ "implementation": "Screen out tobacco, weapons, fossil fuels, etc.",+ "pros": ["Clear ethical alignment", "Simple to implement"],+ "cons": ["May reduce diversification", "Potential return impact"],+ "suitable_for": "Values-driven investors with specific exclusions"+ },+ ESGApproach.BEST_IN_CLASS.value: {+ "description": "Select best ESG performers within each sector",+ "implementation": "Choose top ESG-rated companies in each industry",+ "pros": ["Maintains sector diversification", "Potential for outperformance"],+ "cons": ["May include controversial sectors", "Complex evaluation process"],+ "suitable_for": "Investors seeking ESG improvement without major exclusions"+ },+ ESGApproach.THEMATIC.value: {+ "description": "Invest in themes aligned with sustainable development",+ "implementation": "Focus on clean energy, water, healthcare, education",+ "pros": ["Positive impact potential", "Growth opportunity exposure"],+ "cons": ["Concentration risk", "Potential volatility"],+ "suitable_for": "Investors targeting specific sustainability themes"+ },+ ESGApproach.INTEGRATION.value: {+ "description": "Incorporate ESG factors into traditional analysis",+ "implementation": "ESG factors as part of fundamental analysis",+ "pros": ["Comprehensive risk assessment", "Potential alpha generation"],+ "cons": ["Complex implementation", "Requires ESG expertise"],+ "suitable_for": "Sophisticated investors seeking enhanced risk-return"+ },+ ESGApproach.IMPACT.value: {+ "description": "Target measurable positive social/environmental impact",+ "implementation": "Direct investment in solutions with impact measurement",+ "pros": ["Measurable positive outcomes", "Mission alignment"],+ "cons": ["Limited investment universe", "Potential return trade-offs"],+ "suitable_for": "Impact-focused investors with specific outcome goals"+ },+ ESGApproach.SHAREHOLDER_ENGAGEMENT.value: {+ "description": "Active ownership to influence corporate ESG practices",+ "implementation": "Proxy voting, shareholder resolutions, management dialogue",+ "pros": ["Influence corporate behavior", "Maintain diversification"],+ "cons": ["Requires active management", "Uncertain outcomes"],+ "suitable_for": "Large investors with capacity for active engagement"+ }+ }++ @staticmethod+ def develop_esg_policy(client_profile: InvestorProfile,+ esg_preferences: Dict) -> Dict:+ """Develop ESG policy for portfolio"""++ # Assess ESG priorities+ esg_priorities = ESGIntegration._assess_esg_priorities(esg_preferences)++ # Select appropriate approaches+ recommended_approaches = ESGIntegration._select_esg_approaches(+ esg_priorities, client_profile+ )++ # Develop implementation strategy+ implementation_strategy = ESGIntegration._develop_implementation_strategy(+ recommended_approaches, client_profile+ )++ return {+ "esg_priorities": esg_priorities,+ "recommended_approaches": recommended_approaches,+ "implementation_strategy": implementation_strategy,+ "measurement_framework": ESGIntegration._create_measurement_framework(+ recommended_approaches+ ),+ "reporting_requirements": ESGIntegration._define_reporting_requirements(+ recommended_approaches+ )+ }++ @staticmethod+ def _assess_esg_priorities(esg_preferences: Dict) -> Dict:+ """Assess client ESG priorities"""+ environmental_weight = esg_preferences.get("environmental_importance", 5) / 10+ social_weight = esg_preferences.get("social_importance", 5) / 10+ governance_weight = esg_preferences.get("governance_importance", 5) / 10++ return {+ "environmental_weight": environmental_weight,+ "social_weight": social_weight,+ "governance_weight": governance_weight,+ "primary_focus": max([+ ("environmental", environmental_weight),+ ("social", social_weight),+ ("governance", governance_weight)+ ], key=lambda x: x[1])[0],+ "overall_esg_importance": np.mean([environmental_weight, social_weight, governance_weight])+ }++ @staticmethod+ def _select_esg_approaches(esg_priorities: Dict, client_profile: InvestorProfile) -> List[str]:+ """Select appropriate ESG approaches"""+ approaches = []++ esg_importance = esg_priorities["overall_esg_importance"]++ # High ESG importance+ if esg_importance > 0.7:+ if client_profile.investment_objective == InvestmentObjective.CAPITAL_APPRECIATION:+ approaches.extend([ESGApproach.THEMATIC.value, ESGApproach.INTEGRATION.value])+ else:+ approaches.extend([ESGApproach.BEST_IN_CLASS.value, ESGApproach.INTEGRATION.value])++ # Moderate ESG importance+ elif esg_importance > 0.4:+ approaches.append(ESGApproach.INTEGRATION.value)+ if "exclusions" in client_profile.unique_circumstances:+ approaches.append(ESGApproach.EXCLUSIONARY.value)++ # Low ESG importance+ else:+ approaches.append(ESGApproach.INTEGRATION.value)++ return approaches++class PortfolioPlanning:+ """Main portfolio planning and construction interface"""++ def __init__(self):+ self.ips_framework = IPSFramework()+ self.objectives_framework = ObjectivesFramework()+ self.constraints_analysis = ConstraintsAnalysis()+ self.asset_allocation_framework = AssetAllocationFramework()+ self.construction_principles = PortfolioConstructionPrinciples()+ self.esg_integration = ESGIntegration()++ def create_comprehensive_ips(self, client_profile: InvestorProfile,+ financial_data: Dict,+ esg_preferences: Optional[Dict] = None) -> InvestmentPolicyStatement:+ """Create comprehensive Investment Policy Statement"""++ # Analyze objectives+ return_objectives = self.objectives_framework.analyze_return_objectives(+ client_profile, financial_data+ )+ risk_objectives = self.objectives_framework.analyze_risk_objectives(+ client_profile, return_objectives+ )++ # Analyze constraints+ liquidity_constraints = self.constraints_analysis.analyze_liquidity_constraints(+ client_profile, financial_data+ )+ time_horizon_constraints = self.constraints_analysis.analyze_time_horizon_constraints(+ client_profile+ )+ tax_constraints = self.constraints_analysis.analyze_tax_constraints(client_profile)+ legal_constraints = self.constraints_analysis.analyze_legal_regulatory_constraints(+ client_profile+ )++ # Develop asset allocation+ asset_classes = self.asset_allocation_framework.define_asset_classes()+ strategic_allocation = self.asset_allocation_framework.strategic_asset_allocation(+ client_profile,+ {"return_objectives": return_objectives, "risk_objectives": risk_objectives},+ {+ "liquidity": liquidity_constraints,+ "time_horizon": time_horizon_constraints,+ "tax": tax_constraints,+ "legal": legal_constraints+ },+ asset_classes+ )++ # ESG policy if applicable+ esg_policy = None+ if esg_preferences:+ esg_policy = self.esg_integration.develop_esg_policy(+ client_profile, esg_preferences+ )++ # Create IPS+ ips = InvestmentPolicyStatement(+ client_information=self._compile_client_information(client_profile, financial_data),+ investment_objectives={+ "return_objectives": return_objectives,+ "risk_objectives": risk_objectives+ },+ investment_constraints={+ "liquidity": liquidity_constraints,+ "time_horizon": time_horizon_constraints,+ "tax": tax_constraints,+ "legal_regulatory": legal_constraints,+ "unique_circumstances": self._analyze_unique_circumstances(client_profile)+ },+ investment_guidelines=self._develop_investment_guidelines(+ strategic_allocation, client_profile+ ),+ strategic_asset_allocation=strategic_allocation,+ rebalancing_policy=self._develop_rebalancing_policy(strategic_allocation),+ performance_measurement=self._develop_performance_measurement_framework(+ return_objectives, strategic_allocation+ ),+ responsibilities=self._define_responsibilities(),+ review_schedule=self._establish_review_schedule(client_profile),+ esg_policy=esg_policy+ )++ return ips++ def validate_and_optimize_ips(self, ips: InvestmentPolicyStatement) -> Dict:+ """Validate and provide optimization recommendations for IPS"""++ # Validate IPS+ validation_results = self.ips_framework.validate_ips(ips)++ # Optimization recommendations+ optimization_recommendations = self._generate_optimization_recommendations(ips)++ # Stress test the plan+ stress_test_results = self._stress_test_ips(ips)++ return {+ "validation_results": validation_results,+ "optimization_recommendations": optimization_recommendations,+ "stress_test_results": stress_test_results,+ "implementation_roadmap": self._create_implementation_roadmap(ips)+ }++ def portfolio_construction_analysis(self, ips: InvestmentPolicyStatement,+ market_conditions: Dict) -> Dict:+ """Comprehensive portfolio construction analysis"""++ # Construction framework+ construction_framework = self.construction_principles.construction_framework()++ # Risk budgeting+ risk_budget_analysis = self.construction_principles.risk_budgeting_approach(+ ips.investment_objectives["risk_objectives"]["overall_risk_tolerance"]["overall_risk_tolerance"],+ ips.strategic_asset_allocation["strategic_allocation"]+ )++ # Implementation considerations+ implementation_analysis = self._analyze_implementation_considerations(+ ips, market_conditions+ )++ # Monitoring framework+ monitoring_framework = self._develop_monitoring_framework(ips)++ return {+ "construction_framework": construction_framework,+ "risk_budget_analysis": risk_budget_analysis,+ "implementation_analysis": implementation_analysis,+ "monitoring_framework": monitoring_framework,+ "success_metrics": self._define_success_metrics(ips)+ }++ def _compile_client_information(self, client_profile: InvestorProfile,+ financial_data: Dict) -> Dict:+ """Compile comprehensive client information"""+ return {+ "client_type": client_profile.investor_type.value,+ "investment_objective": client_profile.investment_objective.value,+ "risk_tolerance": client_profile.risk_tolerance,+ "time_horizon": client_profile.time_horizon,+ "liquidity_needs": client_profile.liquidity_needs,+ "financial_situation": {+ "current_assets": financial_data.get("current_portfolio_value", 0),+ "annual_income": financial_data.get("annual_income", 0),+ "annual_expenses": financial_data.get("annual_expenses", 0),+ "net_worth": financial_data.get("net_worth", 0)+ },+ "tax_situation": client_profile.tax_situation,+ "unique_circumstances": client_profile.unique_circumstances+ }++ def _analyze_unique_circumstances(self, client_profile: InvestorProfile) -> Dict:+ """Analyze unique circumstances affecting portfolio"""+ unique_analysis = {+ "circumstances": client_profile.unique_circumstances,+ "portfolio_implications": [],+ "special_considerations": []+ }++ for circumstance in client_profile.unique_circumstances:+ if "concentrated position" in circumstance.lower():+ unique_analysis["portfolio_implications"].append(+ "Diversification challenge due to concentrated position"+ )+ unique_analysis["special_considerations"].append(+ "Consider gradual diversification strategy"+ )++ elif "business ownership" in circumstance.lower():+ unique_analysis["portfolio_implications"].append(+ "High correlation between human capital and financial capital"+ )+ unique_analysis["special_considerations"].append(+ "Emphasize diversification away from business sector"+ )++ elif "inheritance" in circumstance.lower():+ unique_analysis["special_considerations"].append(+ "Consider step-up in basis for tax planning"+ )++ return unique_analysis++ def _develop_investment_guidelines(self, strategic_allocation: Dict,+ client_profile: InvestorProfile) -> Dict:+ """Develop comprehensive investment guidelines"""+ return {+ "asset_allocation_guidelines": {+ "strategic_targets": strategic_allocation["strategic_allocation"],+ "rebalancing_bands": strategic_allocation["rebalancing_bands"],+ "tactical_ranges": self._set_tactical_ranges(strategic_allocation)+ },+ "security_selection_guidelines": {+ "quality_requirements": self._define_quality_requirements(client_profile),+ "diversification_requirements": self._define_diversification_requirements(),+ "liquidity_requirements": self._define_liquidity_requirements(client_profile),+ "cost_guidelines": self._define_cost_guidelines()+ },+ "risk_management_guidelines": {+ "maximum_position_sizes": self._set_position_limits(),+ "prohibited_investments": self._identify_prohibited_investments(client_profile),+ "derivative_usage": self._define_derivative_usage_policy(client_profile)+ }+ }++ def _develop_rebalancing_policy(self, strategic_allocation: Dict) -> Dict:+ """Develop rebalancing policy"""+ return {+ "rebalancing_method": "Threshold-based with calendar review",+ "rebalancing_bands": strategic_allocation["rebalancing_bands"],+ "rebalancing_frequency": {+ "calendar_review": "Quarterly",+ "threshold_monitoring": "Monthly",+ "emergency_rebalancing": "As needed for major market events"+ },+ "rebalancing_priorities": [+ "Bring severely out-of-range allocations back to target",+ "Consider tax implications of rebalancing transactions",+ "Use cash flows to rebalance when possible",+ "Minimize transaction costs"+ ],+ "implementation_guidelines": {+ "minimum_trade_size": "1% of portfolio value",+ "tax_loss_harvesting": "Incorporate when beneficial",+ "cash_flow_utilization": "Use contributions/withdrawals for rebalancing"+ }+ }++ def _develop_performance_measurement_framework(self, return_objectives: Dict,+ strategic_allocation: Dict) -> Dict:+ """Develop performance measurement framework"""+ return {+ "primary_benchmark": self._select_primary_benchmark(strategic_allocation),+ "secondary_benchmarks": self._select_secondary_benchmarks(strategic_allocation),+ "performance_metrics": [+ "Total return vs. benchmark",+ "Risk-adjusted returns (Sharpe ratio)",+ "Maximum drawdown",+ "Tracking error vs. benchmark"+ ],+ "evaluation_periods": {+ "short_term": "1 year",+ "medium_term": "3 years",+ "long_term": "5+ years"+ },+ "performance_attribution": {+ "asset_allocation_effect": "Contribution from strategic allocation decisions",+ "security_selection_effect": "Contribution from security selection",+ "interaction_effect": "Interaction between allocation and selection"+ },+ "reporting_schedule": {+ "monthly": "Portfolio value and basic performance metrics",+ "quarterly": "Comprehensive performance report with attribution",+ "annual": "Full performance review with recommendations"+ }+ }++ def _define_responsibilities(self) -> Dict:+ """Define roles and responsibilities"""+ return {+ "client_responsibilities": [+ "Provide accurate and complete financial information",+ "Communicate changes in circumstances promptly",+ "Review and approve Investment Policy Statement",+ "Make timely decisions on recommended changes"+ ],+ "advisor_responsibilities": [+ "Develop and maintain Investment Policy Statement",+ "Implement investment strategy according to IPS",+ "Monitor portfolio performance and risk",+ "Provide regular reporting and communication",+ "Recommend changes when appropriate"+ ],+ "third_party_responsibilities": [+ "Custodian: Safekeeping of assets and transaction settlement",+ "Portfolio managers: Investment management within guidelines",+ "Other service providers: Specific services as contracted"+ ]+ }++ def _establish_review_schedule(self, client_profile: InvestorProfile) -> Dict:+ """Establish IPS and portfolio review schedule"""+ if client_profile.investor_type == InvestorType.INDIVIDUAL:+ review_frequency = "Annual"+ interim_reviews = "As circumstances change"+ else:+ review_frequency = "Annual or as required by governance"+ interim_reviews = "Quarterly committee reviews"++ return {+ "formal_review_frequency": review_frequency,+ "interim_review_triggers": [+ "Significant changes in client circumstances",+ "Major market events or economic changes",+ "Performance significantly off-track",+ "Changes in investment objectives or constraints"+ ],+ "review_process": {+ "preparation": "Gather performance data and market analysis",+ "review_meeting": "Discuss performance, circumstances, and changes",+ "documentation": "Update IPS if changes are made",+ "implementation": "Execute any approved changes"+ },+ "update_procedures": [+ "Document reasons for any IPS changes",+ "Obtain client approval for material changes",+ "Communicate changes to all relevant parties",+ "Update systems and processes accordingly"+ ]+ }++ def _generate_optimization_recommendations(self, ips: InvestmentPolicyStatement) -> List[str]:+ """Generate IPS optimization recommendations"""+ recommendations = []++ # Check asset allocation efficiency+ allocation = ips.strategic_asset_allocation.get("strategic_allocation", {})+ if len(allocation) < 4:+ recommendations.append("Consider additional asset classes for better diversification")++ # Check rebalancing policy+ if not ips.rebalancing_policy.get("rebalancing_bands"):+ recommendations.append("Establish clear rebalancing bands to maintain strategic allocation")++ # Check performance measurement+ if not ips.performance_measurement.get("primary_benchmark"):+ recommendations.append("Define clear performance benchmarks for evaluation")++ # Check ESG integration+ if not ips.esg_policy and "esg" in str(ips.client_information.get("unique_circumstances", [])).lower():+ recommendations.append("Consider developing ESG policy based on client preferences")++ return recommendations++ def _stress_test_ips(self, ips: InvestmentPolicyStatement) -> Dict:+ """Stress test the IPS under various scenarios"""+ allocation = ips.strategic_asset_allocation.get("strategic_allocation", {})++ # Scenario analysis+ scenarios = {+ "market_crash": {"equity_shock": -0.30, "bond_shock": 0.05},+ "inflation_spike": {"equity_shock": -0.10, "bond_shock": -0.15},+ "recession": {"equity_shock": -0.20, "bond_shock": 0.10}+ }++ stress_results = {}+ for scenario_name, shocks in scenarios.items():+ portfolio_impact = 0+ for asset_class, weight in allocation.items():+ if "equity" in asset_class:+ portfolio_impact += weight * shocks["equity_shock"]+ elif "bond" in asset_class:+ portfolio_impact += weight * shocks["bond_shock"]++ stress_results[scenario_name] = {+ "portfolio_impact": portfolio_impact,+ "severity": "High" if abs(portfolio_impact) > 0.15 else+ "Moderate" if abs(portfolio_impact) > 0.10 else "Low"+ }++ return {+ "scenario_analysis": stress_results,+ "overall_resilience": "Good" if all(abs(result["portfolio_impact"]) < 0.20+ for result in stress_results.values()) else "Moderate",+ "recommendations": self._generate_stress_test_recommendations(stress_results)+ }++ def _create_implementation_roadmap(self, ips: InvestmentPolicyStatement) -> Dict:+ """Create implementation roadmap for IPS"""+ return {+ "phase_1_immediate": {+ "timeframe": "0-30 days",+ "tasks": [+ "Finalize and approve IPS",+ "Set up custodial and administrative accounts",+ "Implement core strategic allocation"+ ]+ },+ "phase_2_buildup": {+ "timeframe": "30-90 days",+ "tasks": [+ "Complete portfolio construction",+ "Implement security selection",+ "Establish monitoring and reporting systems"+ ]+ },+ "phase_3_optimization": {+ "timeframe": "90+ days",+ "tasks": [+ "Fine-tune allocation based on performance",+ "Optimize tax efficiency",+ "Conduct first quarterly review"+ ]+ }+ }++ # Additional helper methods for portfolio construction analysis+ def _analyze_implementation_considerations(self, ips: InvestmentPolicyStatement,+ market_conditions: Dict) -> Dict:+ """Analyze implementation considerations"""+ return {+ "market_timing_considerations": {+ "current_valuations": market_conditions.get("market_valuations", "neutral"),+ "volatility_environment": market_conditions.get("volatility", "normal"),+ "implementation_approach": "Dollar-cost averaging for large allocations"+ },+ "cost_analysis": {+ "estimated_implementation_costs": "0.10% - 0.25% of assets",+ "ongoing_management_fees": "0.50% - 1.50% annually",+ "transaction_cost_minimization": "Use low-cost index funds where appropriate"+ },+ "tax_optimization": {+ "account_type_utilization": "Maximize tax-advantaged account usage",+ "asset_location": "Place tax-inefficient assets in tax-advantaged accounts",+ "transition_management": "Consider tax implications of portfolio transitions"+ }+ }++ def _develop_monitoring_framework(self, ips: InvestmentPolicyStatement) -> Dict:+ """Develop comprehensive monitoring framework"""+ return {+ "daily_monitoring": [+ "Portfolio value and performance",+ "Cash flows and liquidity",+ "Market risk exposures"+ ],+ "monthly_monitoring": [+ "Asset allocation drift",+ "Performance vs. benchmarks",+ "Risk metrics and attribution"+ ],+ "quarterly_monitoring": [+ "Comprehensive performance review",+ "Rebalancing needs assessment",+ "Strategy effectiveness evaluation"+ ],+ "alert_systems": {+ "allocation_alerts": "Trigger when allocation exceeds bands",+ "performance_alerts": "Trigger on significant underperformance",+ "risk_alerts": "Trigger on excessive risk measures"+ }+ }++ def _define_success_metrics(self, ips: InvestmentPolicyStatement) -> Dict:+ """Define success metrics for portfolio"""+ return_target = ips.investment_objectives["return_objectives"]["return_targets"]["primary_return_target"]++ return {+ "primary_success_metrics": {+ "return_achievement": f"Achieve {return_target:.1%} annual return over long term",+ "risk_control": "Stay within defined risk parameters",+ "objective_fulfillment": "Meet stated investment objectives"+ },+ "secondary_success_metrics": {+ "cost_efficiency": "Minimize total investment costs",+ "tax_efficiency": "Optimize after-tax returns",+ "implementation_efficiency": "Minimize tracking error to strategic allocation"+ },+ "measurement_timeframes": {+ "short_term": "1-year rolling periods",+ "medium_term": "3-year rolling periods",+ "long_term": "5+ year periods"+ }+ }++ # Helper methods for guidelines and policies+ def _set_tactical_ranges(self, strategic_allocation: Dict) -> Dict:+ """Set tactical allocation ranges"""+ tactical_ranges = {}+ for asset_class, target in strategic_allocation["strategic_allocation"].items():+ # Allow 25% tactical deviation from strategic target+ deviation = target * 0.25+ tactical_ranges[asset_class] = {+ "minimum": max(0, target - deviation),+ "maximum": min(1, target + deviation)+ }+ return tactical_ranges++ def _define_quality_requirements(self, client_profile: InvestorProfile) -> List[str]:+ """Define security quality requirements"""+ requirements = ["Minimum investment grade rating for fixed income"]++ if client_profile.risk_tolerance == "conservative":+ requirements.extend([+ "Large-cap equity bias",+ "Minimum market capitalization of $2 billion for individual stocks"+ ])++ return requirements++ def _define_diversification_requirements(self) -> List[str]:+ """Define diversification requirements"""+ return [+ "Maximum 5% in any single security",+ "Maximum 25% in any single sector",+ "Minimum 20 individual securities in equity allocation"+ ]++ def _define_liquidity_requirements(self, client_profile: InvestorProfile) -> List[str]:+ """Define liquidity requirements"""+ requirements = ["Minimum daily trading volume of $1 million for individual securities"]++ if client_profile.liquidity_needs > 0.2:+ requirements.append("Maximum 10% in illiquid investments")+ else:+ requirements.append("Maximum 20% in illiquid investments")++ return requirements++ def _define_cost_guidelines(self) -> List[str]:+ """Define cost guidelines"""+ return [+ "Target expense ratios below 0.75% for actively managed funds",+ "Target expense ratios below 0.25% for index funds",+ "Minimize portfolio turnover to reduce transaction costs"+ ]++ def _set_position_limits(self) -> Dict[str, float]:+ """Set maximum position size limits"""+ return {+ "individual_security": 0.05, # 5% maximum+ "sector_concentration": 0.25, # 25% maximum+ "geographic_concentration": 0.60, # 60% maximum in any single country+ "currency_exposure": 0.30 # 30% maximum unhedged foreign currency+ }++ def _identify_prohibited_investments(self, client_profile: InvestorProfile) -> List[str]:+ """Identify prohibited investments"""+ prohibited = ["Penny stocks", "Highly leveraged ETFs (>2x)"]++ # Add based on unique circumstances+ for circumstance in client_profile.unique_circumstances:+ if "no tobacco" in circumstance.lower():+ prohibited.append("Tobacco companies")+ if "no weapons" in circumstance.lower():+ prohibited.append("Defense/weapons manufacturers")++ return prohibited++ def _define_derivative_usage_policy(self, client_profile: InvestorProfile) -> Dict:+ """Define derivative usage policy"""+ if client_profile.risk_tolerance == "conservative":+ return {+ "permitted_derivatives": ["Currency hedging forwards"],+ "prohibited_derivatives": ["Options", "Futures", "Swaps"],+ "usage_purpose": "Hedging only"+ }+ else:+ return {+ "permitted_derivatives": ["Options", "Futures", "Currency hedging"],+ "usage_purpose": "Hedging and limited tactical positioning",+ "maximum_notional": "10% of portfolio value"+ }++ def _select_primary_benchmark(self, strategic_allocation: Dict) -> str:+ """Select primary benchmark based on allocation"""+ allocation = strategic_allocation["strategic_allocation"]++ equity_weight = sum(weight for asset, weight in allocation.items() if "equity" in asset)++ if equity_weight > 0.7:+ return "MSCI All Country World Index"+ elif equity_weight > 0.4:+ return "60/40 Stock/Bond Composite"+ else:+ return "Bloomberg Aggregate Bond Index"++ def _select_secondary_benchmarks(self, strategic_allocation: Dict) -> List[str]:+ """Select secondary benchmarks"""+ allocation = strategic_allocation["strategic_allocation"]+ benchmarks = []++ if "domestic_equity" in allocation:+ benchmarks.append("S&P 500 Index")+ if "international_equity" in allocation:+ benchmarks.append("MSCI EAFE Index")+ if "domestic_bonds" in allocation:+ benchmarks.append("Bloomberg US Aggregate Bond Index")+ if "real_estate" in allocation:+ benchmarks.append("FTSE NAREIT All REITs Index")++ return benchmarks++ def _generate_stress_test_recommendations(self, stress_results: Dict) -> List[str]:+ """Generate recommendations based on stress test results"""+ recommendations = []++ high_impact_scenarios = [scenario for scenario, result in stress_results.items()+ if result["severity"] == "High"]++ if high_impact_scenarios:+ recommendations.append("Consider reducing portfolio risk through increased diversification")++ if "market_crash" in high_impact_scenarios:+ recommendations.append("Consider adding defensive assets or hedge fund strategies")++ if "inflation_spike" in high_impact_scenarios:+ recommendations.append("Consider adding inflation-protected securities or commodities")++ return recommendations\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/risk_management.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/risk_management.pynew file mode 100644index 000000000..520b61883--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/portfolioManagement/risk_management.py@@ -0,0 +1,700 @@++Portfolio Risk Management Module+===============================++Portfolio risk management and mitigation++===== DATA SOURCES REQUIRED =====+INPUT:+ - Portfolio holdings and transaction history+ - Asset price data and market returns+ - Benchmark indices and market data+ - Investment policy statements and constraints+ - Risk tolerance and preference parameters++OUTPUT:+ - Portfolio performance metrics and attribution+ - Risk analysis and diversification metrics+ - Rebalancing recommendations and optimization+ - Portfolio analytics reports and visualizations+ - Investment strategy recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization method (default: 'mean_variance')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 'quarterly')+ - max_weight: Maximum single asset weight (default: 0.10)+ - benchmark: Portfolio benchmark index (default: 'market_index')+++import numpy as np+import pandas as pd+from typing import Dict, List, Optional, Union, Tuple, Callable+from dataclasses import dataclass+from scipy import stats+import warnings++from config import (+ RiskParameters, MathConstants, RiskMetric,+ DEFAULT_RISK_PARAMS, validate_returns, ERROR_MESSAGES+)+from math_engine import RiskCalculations, StatisticalCalculations+++@dataclass+class RiskBudget:+ """Risk budget allocation structure"""+ portfolio_id: str+ total_risk_budget: float+ asset_allocations: Dict[str, float]+ risk_allocations: Dict[str, float]+ risk_limits: Dict[str, float]+++class RiskGovernance:+ """Risk governance framework implementation"""++ def __init__(self):+ self.risk_policies = {}+ self.risk_limits = {}+ self.governance_structure = {}++ def define_risk_policy(self, policy_name: str, policy_details: Dict) -> None:+ """Define risk management policy"""+ required_fields = ["objective", "scope", "methodology", "limits", "reporting"]++ for field in required_fields:+ if field not in policy_details:+ raise ValueError(f"Risk policy must include '{field}'")++ self.risk_policies[policy_name] = {+ "policy_details": policy_details,+ "creation_date": pd.Timestamp.now(),+ "last_review": pd.Timestamp.now(),+ "status": "active"+ }++ def set_risk_limits(self, limit_type: str, limits: Dict) -> None:+ """Set various types of risk limits"""+ valid_types = ["position", "sector", "var", "tracking_error", "leverage", "concentration"]++ if limit_type not in valid_types:+ raise ValueError(f"Limit type must be one of {valid_types}")++ self.risk_limits[limit_type] = limits++ def assess_governance_effectiveness(self) -> Dict:+ """Assess risk governance effectiveness"""+ return {+ "policies_defined": len(self.risk_policies),+ "limits_established": len(self.risk_limits),+ "governance_score": self._calculate_governance_score(),+ "areas_for_improvement": self._identify_improvement_areas()+ }++ def _calculate_governance_score(self) -> float:+ """Calculate governance effectiveness score"""+ base_score = 0++ # Policy coverage+ if len(self.risk_policies) >= 3:+ base_score += 30+ elif len(self.risk_policies) >= 1:+ base_score += 15++ # Limit coverage+ if len(self.risk_limits) >= 4:+ base_score += 40+ elif len(self.risk_limits) >= 2:+ base_score += 20++ # Structure completeness+ required_structures = ["risk_committee", "cro", "risk_reporting"]+ structure_score = sum(20 for struct in required_structures+ if struct in self.governance_structure)+ base_score += structure_score++ return min(100, base_score)++ def _identify_improvement_areas(self) -> List[str]:+ """Identify areas needing improvement"""+ improvements = []++ if len(self.risk_policies) < 3:+ improvements.append("Expand risk policy coverage")++ if "var" not in self.risk_limits:+ improvements.append("Establish VaR limits")++ if "concentration" not in self.risk_limits:+ improvements.append("Set concentration limits")++ required_structures = ["risk_committee", "cro", "risk_reporting"]+ missing_structures = [s for s in required_structures+ if s not in self.governance_structure]+ if missing_structures:+ improvements.append(f"Establish: {', '.join(missing_structures)}")++ return improvements+++class RiskTolerance:+ """Risk tolerance analysis and measurement"""++ @staticmethod+ def assess_risk_capacity(financial_metrics: Dict) -> Dict:+ """Assess quantitative risk capacity"""+ # Financial capacity indicators+ liquidity_ratio = financial_metrics.get("liquid_assets", 0) / financial_metrics.get("total_assets", 1)+ debt_ratio = financial_metrics.get("total_debt", 0) / financial_metrics.get("total_assets", 1)+ income_stability = financial_metrics.get("income_stability_score", 5) # 1-10 scale+ time_horizon = financial_metrics.get("investment_horizon_years", 10)++ # Calculate capacity score+ capacity_score = 0++ # Liquidity component (25%)+ if liquidity_ratio > 0.5:+ capacity_score += 25+ elif liquidity_ratio > 0.3:+ capacity_score += 15+ elif liquidity_ratio > 0.1:+ capacity_score += 10++ # Debt component (25%)+ if debt_ratio < 0.2:+ capacity_score += 25+ elif debt_ratio < 0.4:+ capacity_score += 15+ elif debt_ratio < 0.6:+ capacity_score += 10++ # Income stability (25%)+ capacity_score += (income_stability / 10) * 25++ # Time horizon (25%)+ if time_horizon > 20:+ capacity_score += 25+ elif time_horizon > 10:+ capacity_score += 20+ elif time_horizon > 5:+ capacity_score += 15+ elif time_horizon > 2:+ capacity_score += 10++ return {+ "capacity_score": capacity_score,+ "capacity_level": "High" if capacity_score > 75 else+ "Moderate" if capacity_score > 50 else "Low",+ "liquidity_ratio": liquidity_ratio,+ "debt_ratio": debt_ratio,+ "limiting_factors": RiskTolerance._identify_limiting_factors(+ liquidity_ratio, debt_ratio, income_stability, time_horizon+ )+ }++ @staticmethod+ def assess_risk_willingness(questionnaire_responses: Dict) -> Dict:+ """Assess behavioral risk willingness"""+ # Sample risk tolerance questionnaire scoring+ willingness_score = 0++ # Loss tolerance (30%)+ loss_comfort = questionnaire_responses.get("max_acceptable_loss", 5) # 1-10 scale+ willingness_score += (loss_comfort / 10) * 30++ # Volatility comfort (25%)+ volatility_comfort = questionnaire_responses.get("volatility_comfort", 5)+ willingness_score += (volatility_comfort / 10) * 25++ # Investment experience (20%)+ experience_level = questionnaire_responses.get("investment_experience", 5)+ willingness_score += (experience_level / 10) * 20++ # Risk understanding (25%)+ risk_knowledge = questionnaire_responses.get("risk_knowledge", 5)+ willingness_score += (risk_knowledge / 10) * 25++ return {+ "willingness_score": willingness_score,+ "willingness_level": "High" if willingness_score > 75 else+ "Moderate" if willingness_score > 50 else "Low",+ "emotional_factors": RiskTolerance._analyze_emotional_factors(questionnaire_responses)+ }++ @staticmethod+ def reconcile_capacity_willingness(capacity_result: Dict, willingness_result: Dict) -> Dict:+ """Reconcile capacity and willingness to determine overall risk tolerance"""+ capacity_score = capacity_result["capacity_score"]+ willingness_score = willingness_result["willingness_score"]++ # Use the lower of the two scores (conservative approach)+ overall_score = min(capacity_score, willingness_score)++ # Identify mismatches+ mismatch = abs(capacity_score - willingness_score)+ significant_mismatch = mismatch > 30++ return {+ "overall_risk_tolerance": overall_score,+ "risk_level": "High" if overall_score > 75 else+ "Moderate" if overall_score > 50 else "Low",+ "capacity_willingness_mismatch": significant_mismatch,+ "mismatch_magnitude": mismatch,+ "recommended_approach": RiskTolerance._recommend_approach(+ capacity_score, willingness_score, significant_mismatch+ )+ }++ @staticmethod+ def _identify_limiting_factors(liquidity_ratio: float, debt_ratio: float,+ income_stability: float, time_horizon: float) -> List[str]:+ """Identify factors limiting risk capacity"""+ factors = []++ if liquidity_ratio < 0.2:+ factors.append("Low liquidity")+ if debt_ratio > 0.5:+ factors.append("High debt burden")+ if income_stability < 5:+ factors.append("Income instability")+ if time_horizon < 5:+ factors.append("Short time horizon")++ return factors++ @staticmethod+ def _analyze_emotional_factors(responses: Dict) -> List[str]:+ """Analyze emotional factors affecting willingness"""+ factors = []++ if responses.get("loss_aversion", 5) > 7:+ factors.append("High loss aversion")+ if responses.get("market_timing_belief", 5) > 7:+ factors.append("Market timing bias")+ if responses.get("overconfidence", 5) > 7:+ factors.append("Overconfidence bias")++ return factors++ @staticmethod+ def _recommend_approach(capacity: float, willingness: float, mismatch: bool) -> str:+ """Recommend approach based on capacity/willingness analysis"""+ if not mismatch:+ return "Proceed with aligned risk tolerance level"+ elif capacity > willingness:+ return "Education and gradual risk increase - capacity exceeds willingness"+ else:+ return "Conservative approach recommended - willingness exceeds capacity"+++class VaRCalculations:+ """Comprehensive Value at Risk calculations"""++ @staticmethod+ def parametric_var(returns: np.ndarray, confidence_level: float = 0.95,+ holding_period: int = 1, distribution: str = "normal") -> Dict:+ """Calculate parametric VaR with multiple distributions"""+ if not validate_returns(returns):+ raise ValueError(ERROR_MESSAGES["insufficient_data"])++ returns_array = np.array(returns)++ if distribution == "normal":+ mean_return = np.mean(returns_array)+ std_return = np.std(returns_array, ddof=1)+ z_score = stats.norm.ppf(1 - confidence_level)+ var = -(mean_return + z_score * std_return) * np.sqrt(holding_period)++ elif distribution == "t_distribution":+ # Fit t-distribution+ params = stats.t.fit(returns_array)+ df, loc, scale = params+ t_score = stats.t.ppf(1 - confidence_level, df)+ var = -(loc + t_score * scale) * np.sqrt(holding_period)++ elif distribution == "cornish_fisher":+ # Cornish-Fisher expansion for skewness and kurtosis+ mean_return = np.mean(returns_array)+ std_return = np.std(returns_array, ddof=1)+ skewness = stats.skew(returns_array)+ kurtosis = stats.kurtosis(returns_array, fisher=False)++ z = stats.norm.ppf(1 - confidence_level)+ z_cf = z + (z ** 2 - 1) * skewness / 6 + (z ** 3 - 3 * z) * (kurtosis - 3) / 24+ var = -(mean_return + z_cf * std_return) * np.sqrt(holding_period)++ else:+ raise ValueError("Distribution must be 'normal', 't_distribution', or 'cornish_fisher'")++ return {+ "var": var,+ "confidence_level": confidence_level,+ "holding_period": holding_period,+ "distribution": distribution,+ "mean_return": np.mean(returns_array),+ "volatility": np.std(returns_array, ddof=1),+ "skewness": stats.skew(returns_array),+ "kurtosis": stats.kurtosis(returns_array, fisher=False)+ }++ @staticmethod+ def monte_carlo_var(returns: np.ndarray, confidence_level: float = 0.95,+ holding_period: int = 1, num_simulations: int = 10000,+ distribution_params: Optional[Dict] = None) -> Dict:+ """Calculate Monte Carlo VaR"""+ returns_array = np.array(returns)++ # Fit distribution parameters if not provided+ if distribution_params is None:+ mean_return = np.mean(returns_array)+ std_return = np.std(returns_array, ddof=1)+ distribution_params = {"mean": mean_return, "std": std_return}++ # Generate random scenarios+ np.random.seed(42) # For reproducibility+ simulated_returns = np.random.normal(+ distribution_params["mean"],+ distribution_params["std"],+ (num_simulations, holding_period)+ )++ # Calculate portfolio returns for each simulation+ if holding_period == 1:+ scenario_returns = simulated_returns.flatten()+ else:+ # Compound returns over holding period+ scenario_returns = np.prod(1 + simulated_returns, axis=1) - 1++ # Calculate VaR+ var = -np.percentile(scenario_returns, (1 - confidence_level) * 100)++ return {+ "var": var,+ "confidence_level": confidence_level,+ "holding_period": holding_period,+ "num_simulations": num_simulations,+ "simulated_returns": scenario_returns,+ "mean_simulated": np.mean(scenario_returns),+ "std_simulated": np.std(scenario_returns)+ }++ @staticmethod+ def component_var(portfolio_returns: np.ndarray, asset_returns: np.ndarray,+ weights: np.ndarray, confidence_level: float = 0.95) -> Dict:+ """Calculate component VaR contributions"""+ # Portfolio VaR+ portfolio_var = RiskCalculations.value_at_risk_historical(portfolio_returns, confidence_level)++ # Calculate marginal VaR for each asset+ marginal_vars = []+ component_vars = []++ for i in range(len(weights)):+ # Small perturbation to weight+ epsilon = 0.001+ perturbed_weights = weights.copy()+ perturbed_weights[i] += epsilon+ perturbed_weights = perturbed_weights / np.sum(perturbed_weights) # Renormalize++ # Calculate perturbed portfolio returns+ perturbed_portfolio_returns = np.dot(asset_returns, perturbed_weights)+ perturbed_var = RiskCalculations.value_at_risk_historical(perturbed_portfolio_returns, confidence_level)++ # Marginal VaR+ marginal_var = (perturbed_var - portfolio_var) / epsilon+ marginal_vars.append(marginal_var)++ # Component VaR+ component_var = marginal_var * weights[i]+ component_vars.append(component_var)++ return {+ "portfolio_var": portfolio_var,+ "marginal_vars": np.array(marginal_vars),+ "component_vars": np.array(component_vars),+ "component_percentages": np.array(component_vars) / np.sum(np.abs(component_vars)) * 100,+ "diversification_benefit": portfolio_var - np.sum(component_vars)+ }+++class ScenarioAnalysis:+ """Scenario-based risk analysis"""++ @staticmethod+ def stress_testing(returns: np.ndarray, stress_scenarios: Dict[str, float]) -> Dict:+ """Perform stress testing on portfolio"""+ results = {}++ for scenario_name, shock in stress_scenarios.items():+ # Apply shock to returns+ stressed_returns = returns + shock++ # Calculate metrics under stress+ stressed_mean = np.mean(stressed_returns)+ stressed_std = np.std(stressed_returns, ddof=1)+ stressed_var_95 = RiskCalculations.value_at_risk_historical(stressed_returns, 0.95)+ stressed_var_99 = RiskCalculations.value_at_risk_historical(stressed_returns, 0.99)++ results[scenario_name] = {+ "shock_applied": shock,+ "stressed_mean_return": stressed_mean,+ "stressed_volatility": stressed_std,+ "stressed_var_95": stressed_var_95,+ "stressed_var_99": stressed_var_99,+ "return_impact": stressed_mean - np.mean(returns),+ "volatility_impact": stressed_std - np.std(returns, ddof=1)+ }++ return results++ @staticmethod+ def historical_scenario_analysis(current_portfolio: np.ndarray,+ historical_market_data: Dict[str, np.ndarray],+ crisis_periods: Dict[str, Tuple[str, str]]) -> Dict:+ """Analyze portfolio performance during historical crisis periods"""+ results = {}++ for crisis_name, (start_date, end_date) in crisis_periods.items():+ crisis_results = {}++ for asset, returns in historical_market_data.items():+ # Filter returns for crisis period (simplified - assumes daily data)+ # In practice, would need proper date filtering+ crisis_returns = returns # Placeholder++ if len(crisis_returns) > 0:+ crisis_results[asset] = {+ "total_return": np.prod(1 + crisis_returns) - 1,+ "volatility": np.std(crisis_returns, ddof=1) * np.sqrt(252),+ "max_drawdown": np.min(np.cumsum(crisis_returns)),+ "worst_day": np.min(crisis_returns)+ }++ # Portfolio-level crisis analysis+ if crisis_results:+ portfolio_crisis_returns = np.zeros(len(next(iter(crisis_results.values()))["total_return"]))+ # This would need proper implementation based on actual data structure++ results[crisis_name] = {+ "period": f"{start_date} to {end_date}",+ "asset_performance": crisis_results,+ "portfolio_impact": "Calculation needed with proper data structure"+ }++ return results+++class RiskBudgetingSystem:+ """Risk budgeting and allocation framework"""++ def __init__(self, total_risk_budget: float):+ self.total_risk_budget = total_risk_budget+ self.allocations = {}+ self.current_utilization = 0.0++ def allocate_risk_budget(self, allocation_name: str, risk_amount: float,+ allocation_type: str = "absolute") -> None:+ """Allocate portion of risk budget"""+ if allocation_type == "absolute":+ if self.current_utilization + risk_amount > self.total_risk_budget:+ raise ValueError("Risk allocation exceeds total budget")++ self.allocations[allocation_name] = {+ "risk_amount": risk_amount,+ "percentage": risk_amount / self.total_risk_budget * 100,+ "type": "absolute"+ }+ self.current_utilization += risk_amount++ elif allocation_type == "percentage":+ risk_amount_abs = risk_amount * self.total_risk_budget / 100+ if self.current_utilization + risk_amount_abs > self.total_risk_budget:+ raise ValueError("Risk allocation exceeds total budget")++ self.allocations[allocation_name] = {+ "risk_amount": risk_amount_abs,+ "percentage": risk_amount,+ "type": "percentage"+ }+ self.current_utilization += risk_amount_abs++ def monitor_risk_utilization(self, current_risks: Dict[str, float]) -> Dict:+ """Monitor current risk utilization vs. budget"""+ utilization_report = {}+ total_current_risk = 0++ for allocation_name, budget_info in self.allocations.items():+ current_risk = current_risks.get(allocation_name, 0)+ budgeted_risk = budget_info["risk_amount"]++ utilization_report[allocation_name] = {+ "budgeted_risk": budgeted_risk,+ "current_risk": current_risk,+ "utilization_percentage": current_risk / budgeted_risk * 100 if budgeted_risk > 0 else 0,+ "excess_risk": max(0, current_risk - budgeted_risk),+ "available_budget": max(0, budgeted_risk - current_risk)+ }++ total_current_risk += current_risk++ return {+ "individual_allocations": utilization_report,+ "total_budget": self.total_risk_budget,+ "total_current_risk": total_current_risk,+ "overall_utilization": total_current_risk / self.total_risk_budget * 100,+ "remaining_budget": self.total_risk_budget - total_current_risk,+ "budget_breaches": [name for name, info in utilization_report.items()+ if info["excess_risk"] > 0]+ }++ def rebalance_risk_budget(self, target_allocations: Dict[str, float]) -> Dict:+ """Rebalance risk budget allocations"""+ if sum(target_allocations.values()) > 100:+ raise ValueError("Target allocations exceed 100%")++ rebalancing_plan = {}++ for allocation_name, target_percentage in target_allocations.items():+ target_risk = target_percentage * self.total_risk_budget / 100+ current_risk = self.allocations.get(allocation_name, {}).get("risk_amount", 0)++ rebalancing_plan[allocation_name] = {+ "current_allocation": current_risk,+ "target_allocation": target_risk,+ "adjustment_needed": target_risk - current_risk,+ "adjustment_percentage": ((target_risk - current_risk) / current_risk * 100) if current_risk > 0 else 0+ }++ return {+ "rebalancing_plan": rebalancing_plan,+ "total_adjustments": sum(abs(info["adjustment_needed"]) for info in rebalancing_plan.values()),+ "implementation_priority": self._prioritize_adjustments(rebalancing_plan)+ }++ def _prioritize_adjustments(self, rebalancing_plan: Dict) -> List[str]:+ """Prioritize risk budget adjustments"""+ # Prioritize by magnitude of adjustment needed+ adjustments = [(name, abs(info["adjustment_needed"]))+ for name, info in rebalancing_plan.items()]+ adjustments.sort(key=lambda x: x[1], reverse=True)++ return [name for name, _ in adjustments]+++class RiskManagement:+ """Main risk management interface"""++ def __init__(self, parameters: RiskParameters = DEFAULT_RISK_PARAMS):+ self.parameters = parameters+ self.governance = RiskGovernance()+ self.risk_budgeting = None++ def comprehensive_risk_analysis(self, returns_data: Union[np.ndarray, Dict[str, np.ndarray]],+ weights: Optional[np.ndarray] = None,+ portfolio_value: float = 1000000) -> Dict:+ """Perform comprehensive risk analysis"""++ if isinstance(returns_data, dict):+ # Multiple assets+ returns_matrix = np.array([returns_data[asset] for asset in returns_data.keys()]).T+ if weights is None:+ weights = np.ones(len(returns_data)) / len(returns_data)+ portfolio_returns = np.dot(returns_matrix, weights)+ asset_names = list(returns_data.keys())+ else:+ # Single asset or portfolio+ portfolio_returns = np.array(returns_data)+ returns_matrix = portfolio_returns.reshape(-1, 1)+ weights = np.array([1.0])+ asset_names = ["Portfolio"]++ results = {+ "basic_risk_metrics": self._calculate_basic_risk_metrics(portfolio_returns),+ "var_analysis": self._comprehensive_var_analysis(portfolio_returns),+ "stress_testing": self._perform_stress_testing(portfolio_returns),+ "risk_decomposition": None+ }++ # Component analysis for multi-asset portfolios+ if len(asset_names) > 1:+ results["risk_decomposition"] = VaRCalculations.component_var(+ portfolio_returns, returns_matrix, weights+ )++ # Convert to dollar amounts+ results["dollar_metrics"] = self._convert_to_dollar_metrics(results, portfolio_value)++ return results++ def _calculate_basic_risk_metrics(self, returns: np.ndarray) -> Dict:+ """Calculate basic risk metrics"""+ return {+ "volatility_daily": np.std(returns, ddof=1),+ "volatility_annual": np.std(returns, ddof=1) * np.sqrt(MathConstants.TRADING_DAYS_YEAR),+ "downside_deviation": StatisticalCalculations.calculate_downside_deviation(returns),+ "max_drawdown": self._calculate_max_drawdown(returns),+ "skewness": stats.skew(returns),+ "kurtosis": stats.kurtosis(returns, fisher=False),+ "jarque_bera_test": stats.jarque_bera(returns)+ }++ def _comprehensive_var_analysis(self, returns: np.ndarray) -> Dict:+ """Comprehensive VaR analysis with multiple methods"""+ var_results = {}++ for confidence_level in self.parameters.var_confidence_levels:+ var_results[f"var_{int(confidence_level * 100)}"] = {+ "parametric_normal": VaRCalculations.parametric_var(+ returns, confidence_level, distribution="normal"+ ),+ "parametric_t": VaRCalculations.parametric_var(+ returns, confidence_level, distribution="t_distribution"+ ),+ "historical": {+ "var": RiskCalculations.value_at_risk_historical(returns, confidence_level),+ "cvar": RiskCalculations.conditional_value_at_risk(returns, confidence_level)+ },+ "monte_carlo": VaRCalculations.monte_carlo_var(+ returns, confidence_level, num_simulations=self.parameters.monte_carlo_simulations+ )+ }++ return var_results++ def _perform_stress_testing(self, returns: np.ndarray) -> Dict:+ """Perform comprehensive stress testing"""+ return ScenarioAnalysis.stress_testing(returns, self.parameters.stress_scenarios)++ def _calculate_max_drawdown(self, returns: np.ndarray) -> Dict:+ """Calculate maximum drawdown statistics"""+ cumulative_returns = np.cumprod(1 + returns)+ running_max = np.maximum.accumulate(cumulative_returns)+ drawdown = (cumulative_returns - running_max) / running_max++ max_dd = np.min(drawdown)+ max_dd_idx = np.argmin(drawdown)+ peak_idx = np.argmax(running_max[:max_dd_idx + 1]) if max_dd_idx > 0 else 0++ return {+ "max_drawdown": max_dd,+ "peak_to_trough_days": max_dd_idx - peak_idx,+ "drawdown_series": drawdown+ }++ def _convert_to_dollar_metrics(self, results: Dict, portfolio_value: float) -> Dict:+ """Convert percentage metrics to dollar amounts"""+ dollar_metrics = {}++ if "var_analysis" in results:+ for var_level, var_data in results["var_analysis"].items():+ dollar_metrics[var_level] = {}++ if "historical" in var_data:+ dollar_metrics[var_level]["historical_var"] = var_data["historical"]["var"] * portfolio_value+ dollar_metrics[var_level]["historical_cvar"] = var_data["historical"]["cvar"] * portfolio_value++ if "parametric_normal" in var_data:+ dollar_metrics[var_level]["parametric_var"] = var_data["parametric_normal"]["var"] * portfolio_value++ return dollar_metrics\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/pyportfolioOpt_wrapper.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/pyportfolioOpt_wrapper.pynew file mode 100644index 000000000..25e0269df--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/pyportfolioOpt_wrapper.py@@ -0,0 +1,1178 @@+"""+Portfolio Optimization Analytics Module+======================================++Advanced portfolio optimization and risk management using PyPortfolioOpt library.+Provides sophisticated portfolio analytics including efficient frontier analysis,+multiple optimization methods, Black-Litterman modeling, and comprehensive+performance attribution capabilities.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Pandas DataFrame with asset price data (datetime index, asset columns)+ - Market capitalizations (for Black-Litterman)+ - Factor data (optional, for factor models)+ - Portfolio constraints and parameters++OUTPUT:+ - Optimal portfolio weights+ - Performance metrics (returns, volatility, Sharpe ratio)+ - Risk decomposition and attribution+ - Efficient frontier data+ - Backtest results with drawdown analysis+ - Discrete allocation recommendations++PARAMETERS:+ - optimization_method: Portfolio optimization algorithm (default: 'efficient_frontier')+ - objective: Optimization objective (default: 'max_sharpe')+ - risk_free_rate: Risk-free rate for calculations (default: 0.02)+ - expected_returns_method: Return estimation method (default: 'mean_historical_return')+ - risk_model_method: Risk model for covariance (default: 'sample_cov')+ - rebalance_frequency: Days between rebalancing (default: 21)+ - confidence_level: Statistical confidence level (default: 0.95)+ - num_simulations: Monte Carlo simulations (default: 1000)+"""+++import pandas as pd+import numpy as np+import matplotlib.pyplot as plt+import plotly.graph_objects as go+import plotly.express as px+from plotly.subplots import make_subplots+import seaborn as sns+import warnings+from typing import Dict, List, Optional, Union, Tuple, Any+from dataclasses import dataclass, field+from datetime import datetime, timedelta+import json+import cvxpy as cp++# PyPortfolioOpt imports+from pypfopt import EfficientFrontier, EfficientSemivariance, EfficientCVaR, EfficientCDaR+from pypfopt import expected_returns, risk_models, objective_functions+from pypfopt import HRPOpt, CLA, BlackLittermanModel+from pypfopt.discrete_allocation import DiscreteAllocation, get_latest_prices+from pypfopt.plotting import plot_covariance, plot_dendrogram, plot_efficient_frontier+from pypfopt import base_optimizer+from pypfopt.utils import portfolio_performance++warnings.filterwarnings('ignore')+++@dataclass+class PyPortfolioOptConfig:+ """Configuration class for PyPortfolioOpt parameters"""++ # Expected Returns Method+ expected_returns_method: str = "mean_historical_return" # mean_historical_return, ema_historical_return, capm_return++ # Risk Model Method+ risk_model_method: str = "sample_cov" # sample_cov, semicovariance, exp_cov, shrunk_covariance, ledoit_wolf++ # Optimization Method+ optimization_method: str = "efficient_frontier" # efficient_frontier, hrp, cla, black_litterman, efficient_semivariance, efficient_cvar, efficient_cdar++ # Objective Function+ objective: str = "max_sharpe" # max_sharpe, min_volatility, max_quadratic_utility, efficient_risk, efficient_return++ # Risk-free rate+ risk_free_rate: float = 0.02++ # Utility function parameters+ risk_aversion: float = 1+ market_neutral: bool = False++ # Constraints+ weight_bounds: Tuple[float, float] = (0, 1) # (min_weight, max_weight)+ sector_constraints: Optional[Dict[str, Tuple[float, float]]] = None++ # L2 Regularization+ gamma: float = 0 # L2 regularization parameter++ # Expected returns parameters+ span: int = 500 # Span for EMA+ frequency: int = 252 # Trading days per year++ # Risk model parameters+ delta: float = 0.95 # Exponential decay for exp_cov+ shrinkage_target: str = "constant_variance" # For shrunk_covariance++ # CVaR/CDaR parameters+ beta: float = 0.95 # Confidence level for CVaR/CDaR++ # Black-Litterman parameters+ tau: float = 0.1 # Uncertainty scaling factor+ market_caps: Optional[pd.Series] = None # Market capitalizations+ views: Optional[Dict[str, float]] = None # Absolute views+ view_confidences: Optional[List[float]] = None # View confidences++ # HRP parameters+ linkage_method: str = "ward" # ward, single, complete, average+ distance_metric: str = "euclidean" # euclidean, correlation++ # Discrete allocation parameters+ total_portfolio_value: float = 10000++ # Advanced constraints+ turnover_constraint: Optional[float] = None # Max turnover from previous weights+ tracking_error_constraint: Optional[float] = None # Max tracking error vs benchmark+++class PyPortfolioOptAnalyticsEngine:+ """+ Advanced PyPortfolioOpt Portfolio Analytics Engine++ Features:+ - Multiple optimization methods (EF, HRP, CLA, Black-Litterman)+ - Various risk models and expected return estimators+ - Advanced constraints and regularization+ - Efficient frontier generation+ - Discrete allocation+ - Performance analysis and plotting+ - Comprehensive backtesting+ """++ def __init__(self, config: PyPortfolioOptConfig = None):+ self.config = config or PyPortfolioOptConfig()+ self.prices = None+ self.returns = None+ self.expected_returns = None+ self.risk_model = None+ self.optimizer = None+ self.weights = None+ self.discrete_allocation = None+ self.performance_metrics = {}+ self.efficient_frontier_data = {}+ self.backtest_results = {}++ def load_data(self,+ prices: pd.DataFrame,+ start_date: str = None,+ end_date: str = None) -> None:+ """+ Load price data and calculate returns++ Parameters:+ -----------+ prices : pd.DataFrame+ Price data with datetime index and asset columns+ start_date, end_date : str+ Date range for filtering+ """+ # Filter by date range+ if start_date or end_date:+ if start_date:+ prices = prices[prices.index >= start_date]+ if end_date:+ prices = prices[prices.index <= end_date]++ self.prices = prices+ self.returns = prices.pct_change().dropna()++ print(f"Data loaded: {len(self.prices)} periods, {len(self.prices.columns)} assets")++ def calculate_expected_returns(self, method: str = None) -> pd.Series:+ """+ Calculate expected returns using specified method++ Parameters:+ -----------+ method : str+ Method for calculating expected returns++ Returns:+ --------+ Expected returns series+ """+ method = method or self.config.expected_returns_method++ if method == "mean_historical_return":+ self.expected_returns = expected_returns.mean_historical_return(+ self.prices, frequency=self.config.frequency+ )+ elif method == "ema_historical_return":+ self.expected_returns = expected_returns.ema_historical_return(+ self.prices, span=self.config.span, frequency=self.config.frequency+ )+ elif method == "capm_return":+ # Requires market data - using mean as fallback+ self.expected_returns = expected_returns.capm_return(+ self.prices, frequency=self.config.frequency+ )+ else:+ raise ValueError(f"Unknown expected returns method: {method}")++ return self.expected_returns++ def calculate_risk_model(self, method: str = None) -> pd.DataFrame:+ """+ Calculate risk model (covariance matrix) using specified method++ Parameters:+ -----------+ method : str+ Method for calculating risk model++ Returns:+ --------+ Covariance matrix+ """+ method = method or self.config.risk_model_method++ if method == "sample_cov":+ self.risk_model = risk_models.sample_cov(+ self.prices, frequency=self.config.frequency+ )+ elif method == "semicovariance":+ self.risk_model = risk_models.semicovariance(+ self.prices, frequency=self.config.frequency+ )+ elif method == "exp_cov":+ self.risk_model = risk_models.exp_cov(+ self.prices, span=self.config.span, frequency=self.config.frequency+ )+ elif method == "shrunk_covariance":+ self.risk_model = risk_models.CovarianceShrinkage(+ self.prices, frequency=self.config.frequency+ ).shrunk_covariance(shrinkage_target=self.config.shrinkage_target)+ elif method == "ledoit_wolf":+ self.risk_model = risk_models.CovarianceShrinkage(+ self.prices, frequency=self.config.frequency+ ).ledoit_wolf()+ else:+ raise ValueError(f"Unknown risk model method: {method}")++ return self.risk_model++ def black_litterman_optimization(self,+ market_caps: pd.Series = None,+ views: Dict[str, float] = None,+ view_confidences: List[float] = None,+ tau: float = None) -> pd.Series:+ """+ Perform Black-Litterman optimization++ Parameters:+ -----------+ market_caps : pd.Series+ Market capitalizations+ views : Dict[str, float]+ Absolute views on expected returns+ view_confidences : List[float]+ Confidence in each view (0-1)+ tau : float+ Uncertainty scaling factor++ Returns:+ --------+ Optimal portfolio weights+ """+ market_caps = market_caps or self.config.market_caps+ views = views or self.config.views+ view_confidences = view_confidences or self.config.view_confidences+ tau = tau or self.config.tau++ # If no market caps provided, use equal weights+ if market_caps is None:+ market_caps = pd.Series(1, index=self.prices.columns)++ # Calculate risk model if not done+ if self.risk_model is None:+ self.calculate_risk_model()++ # Create Black-Litterman model+ bl = BlackLittermanModel(+ cov_matrix=self.risk_model,+ pi="market", # Use market-implied returns+ market_caps=market_caps,+ tau=tau+ )++ # Add views if provided+ if views:+ view_dict = {}+ for asset, view_return in views.items():+ if asset in self.prices.columns:+ view_dict[asset] = view_return++ if view_dict:+ bl.add_views(view_dict, view_confidences)++ # Get posterior estimates+ ret_bl = bl.bl_returns()+ cov_bl = bl.bl_cov()++ # Optimize portfolio+ ef = EfficientFrontier(ret_bl, cov_bl, weight_bounds=self.config.weight_bounds)++ if self.config.objective == "max_sharpe":+ self.weights = ef.max_sharpe(risk_free_rate=self.config.risk_free_rate)+ elif self.config.objective == "min_volatility":+ self.weights = ef.min_volatility()+ else:+ raise ValueError(f"Objective {self.config.objective} not supported for Black-Litterman")++ self.optimizer = ef+ return pd.Series(self.weights)+++def cla_optimization(self) -> pd.Series:+ """+ Perform Critical Line Algorithm optimization++ Returns:+ --------+ Optimal portfolio weights+ """+ # Calculate expected returns and risk model if not done+ if self.expected_returns is None:+ self.calculate_expected_returns()+ if self.risk_model is None:+ self.calculate_risk_model()++ # Create CLA optimizer+ cla = CLA(self.expected_returns, self.risk_model, weight_bounds=self.config.weight_bounds)++ if self.config.objective == "max_sharpe":+ self.weights = cla.max_sharpe(risk_free_rate=self.config.risk_free_rate)+ elif self.config.objective == "min_volatility":+ self.weights = cla.min_volatility()+ else:+ # For other objectives, use efficient frontier approach+ self.weights = cla.max_sharpe(risk_free_rate=self.config.risk_free_rate)++ self.optimizer = cla+ return pd.Series(self.weights)+++def efficient_semivariance_optimization(self, target_return: float = None) -> pd.Series:+ """+ Perform efficient semivariance optimization++ Parameters:+ -----------+ target_return : float+ Target return for optimization++ Returns:+ --------+ Optimal portfolio weights+ """+ # Use historical returns for semivariance+ historical_rets = expected_returns.returns_from_prices(self.prices)++ # Create efficient semivariance optimizer+ es = EfficientSemivariance(self.expected_returns, historical_rets,+ weight_bounds=self.config.weight_bounds)++ if self.config.objective == "min_volatility":+ if target_return:+ self.weights = es.efficient_semivariance(target_semivariance=target_return)+ else:+ # Minimize semivariance for target return of 10%+ self.weights = es.efficient_semivariance(target_semivariance=0.1)+ else:+ raise ValueError(f"Objective {self.config.objective} not supported for semivariance")++ self.optimizer = es+ return pd.Series(self.weights)+++def efficient_cvar_optimization(self, target_return: float = None, beta: float = None) -> pd.Series:+ """+ Perform efficient CVaR optimization++ Parameters:+ -----------+ target_return : float+ Target return for optimization+ beta : float+ Confidence level for CVaR++ Returns:+ --------+ Optimal portfolio weights+ """+ beta = beta or self.config.beta+ historical_rets = expected_returns.returns_from_prices(self.prices)++ # Create efficient CVaR optimizer+ ec = EfficientCVaR(self.expected_returns, historical_rets, beta=beta,+ weight_bounds=self.config.weight_bounds)++ if self.config.objective == "min_volatility":+ if target_return:+ self.weights = ec.efficient_return(target_return=target_return)+ else:+ self.weights = ec.min_cvar()+ elif self.config.objective == "max_sharpe":+ # CVaR doesn't have direct max_sharpe, use min_cvar+ self.weights = ec.min_cvar()+ else:+ self.weights = ec.min_cvar()++ self.optimizer = ec+ return pd.Series(self.weights)+++def efficient_cdar_optimization(self, target_return: float = None, beta: float = None) -> pd.Series:+ """+ Perform efficient CDaR optimization++ Parameters:+ -----------+ target_return : float+ Target return for optimization+ beta : float+ Confidence level for CDaR++ Returns:+ --------+ Optimal portfolio weights+ """+ beta = beta or self.config.beta+ historical_rets = expected_returns.returns_from_prices(self.prices)++ # Create efficient CDaR optimizer+ ecd = EfficientCDaR(self.expected_returns, historical_rets, beta=beta,+ weight_bounds=self.config.weight_bounds)++ if self.config.objective == "min_volatility":+ if target_return:+ self.weights = ecd.efficient_return(target_return=target_return)+ else:+ self.weights = ecd.min_cdar()+ else:+ self.weights = ecd.min_cdar()++ self.optimizer = ecd+ return pd.Series(self.weights)+++def optimize_portfolio(self,+ method: str = None,+ objective: str = None) -> pd.Series:+ """+ Main portfolio optimization method++ Parameters:+ -----------+ method : str+ Optimization method to use+ objective : str+ Optimization objective++ Returns:+ --------+ Optimal portfolio weights+ """+ method = method or self.config.optimization_method+ objective = objective or self.config.objective++ # Update config+ self.config.objective = objective++ if method == "efficient_frontier":+ return self._efficient_frontier_optimization()+ elif method == "hrp":+ return self.hrp_optimization()+ elif method == "cla":+ return self.cla_optimization()+ elif method == "black_litterman":+ return self.black_litterman_optimization()+ elif method == "efficient_semivariance":+ return self.efficient_semivariance_optimization()+ elif method == "efficient_cvar":+ return self.efficient_cvar_optimization()+ elif method == "efficient_cdar":+ return self.efficient_cdar_optimization()+ else:+ raise ValueError(f"Unknown optimization method: {method}")+++def _efficient_frontier_optimization(self) -> pd.Series:+ """Internal method for standard efficient frontier optimization"""+ # Calculate expected returns and risk model if not done+ if self.expected_returns is None:+ self.calculate_expected_returns()+ if self.risk_model is None:+ self.calculate_risk_model()++ # Create efficient frontier+ ef = EfficientFrontier(self.expected_returns, self.risk_model,+ weight_bounds=self.config.weight_bounds, gamma=self.config.gamma)++ # Add sector constraints if provided+ if self.config.sector_constraints:+ for sector, (lower, upper) in self.config.sector_constraints.items():+ # This would require sector mapping - simplified for demo+ pass++ # Optimize based on objective+ if self.config.objective == "max_sharpe":+ self.weights = ef.max_sharpe(risk_free_rate=self.config.risk_free_rate)+ elif self.config.objective == "min_volatility":+ self.weights = ef.min_volatility()+ elif self.config.objective == "max_quadratic_utility":+ self.weights = ef.max_quadratic_utility(risk_aversion=self.config.risk_aversion,+ market_neutral=self.config.market_neutral)+ elif self.config.objective == "efficient_risk":+ # Requires target volatility - using 15% as default+ self.weights = ef.efficient_risk(target_volatility=0.15,+ market_neutral=self.config.market_neutral)+ elif self.config.objective == "efficient_return":+ # Requires target return - using 12% as default+ self.weights = ef.efficient_return(target_return=0.12,+ market_neutral=self.config.market_neutral)+ else:+ raise ValueError(f"Unknown objective: {self.config.objective}")++ self.optimizer = ef+ return pd.Series(self.weights)+++def generate_efficient_frontier(self, num_points: int = 100) -> Dict[str, Any]:+ """+ Generate efficient frontier data++ Parameters:+ -----------+ num_points : int+ Number of points to generate on frontier++ Returns:+ --------+ Dictionary with frontier data+ """+ # Calculate expected returns and risk model if not done+ if self.expected_returns is None:+ self.calculate_expected_returns()+ if self.risk_model is None:+ self.calculate_risk_model()++ # Generate frontier+ ef = EfficientFrontier(self.expected_returns, self.risk_model,+ weight_bounds=self.config.weight_bounds)++ # Get min and max return bounds+ min_ret = self.expected_returns.min()+ max_ret = self.expected_returns.max()++ # Generate target returns+ target_returns = np.linspace(min_ret, max_ret * 0.95, num_points)++ frontier_volatility = []+ frontier_returns = []+ frontier_sharpe = []++ for target_ret in target_returns:+ try:+ ef_temp = EfficientFrontier(self.expected_returns, self.risk_model,+ weight_bounds=self.config.weight_bounds)+ weights = ef_temp.efficient_return(target_return=target_ret,+ market_neutral=self.config.market_neutral)+ ret, vol, sharpe = ef_temp.portfolio_performance(risk_free_rate=self.config.risk_free_rate)++ frontier_returns.append(ret)+ frontier_volatility.append(vol)+ frontier_sharpe.append(sharpe)++ except Exception:+ continue++ self.efficient_frontier_data = {+ 'returns': frontier_returns,+ 'volatility': frontier_volatility,+ 'sharpe_ratios': frontier_sharpe,+ 'num_points': len(frontier_returns)+ }++ return self.efficient_frontier_data+++def discrete_allocation(self,+ latest_prices: pd.Series = None,+ total_portfolio_value: float = None) -> Dict[str, Any]:+ """+ Convert optimal weights to discrete share allocation++ Parameters:+ -----------+ latest_prices : pd.Series+ Latest prices for assets+ total_portfolio_value : float+ Total value to allocate++ Returns:+ --------+ Dictionary with discrete allocation+ """+ if self.weights is None:+ raise ValueError("No weights available. Run optimization first.")++ total_portfolio_value = total_portfolio_value or self.config.total_portfolio_value++ # Get latest prices if not provided+ if latest_prices is None:+ latest_prices = get_latest_prices(self.prices)++ # Perform discrete allocation+ da = DiscreteAllocation(self.weights, latest_prices, total_portfolio_value=total_portfolio_value)+ allocation, leftover = da.lp_portfolio()++ self.discrete_allocation = {+ 'allocation': allocation,+ 'leftover_cash': leftover,+ 'total_value': total_portfolio_value,+ 'allocated_value': total_portfolio_value - leftover+ }++ return self.discrete_allocation+++def portfolio_performance(self, weights: pd.Series = None) -> Tuple[float, float, float]:+ """+ Calculate portfolio performance metrics++ Parameters:+ -----------+ weights : pd.Series+ Portfolio weights (uses optimized weights if None)++ Returns:+ --------+ Tuple of (expected_return, volatility, sharpe_ratio)+ """+ weights = weights if weights is not None else pd.Series(self.weights)++ if self.expected_returns is None:+ self.calculate_expected_returns()+ if self.risk_model is None:+ self.calculate_risk_model()++ # Calculate performance+ ret, vol, sharpe = portfolio_performance(+ weights, self.expected_returns, self.risk_model,+ risk_free_rate=self.config.risk_free_rate+ )++ self.performance_metrics = {+ 'expected_return': ret,+ 'volatility': vol,+ 'sharpe_ratio': sharpe+ }++ return ret, vol, sharpe+++def backtest_strategy(self,+ rebalance_frequency: int = 21,+ lookback_period: int = 252,+ start_date: str = None) -> pd.DataFrame:+ """+ Backtest the optimization strategy using rolling windows++ Parameters:+ -----------+ rebalance_frequency : int+ Rebalancing frequency in days+ lookback_period : int+ Lookback period for optimization+ start_date : str+ Start date for backtest++ Returns:+ --------+ DataFrame with backtest results+ """+ if start_date:+ prices = self.prices[self.prices.index >= start_date]+ else:+ prices = self.prices.copy()++ # Ensure we have enough data+ if len(prices) < lookback_period + rebalance_frequency:+ raise ValueError("Insufficient data for backtesting")++ backtest_dates = []+ portfolio_returns = []+ weights_history = []++ # Rolling backtest+ for i in range(lookback_period, len(prices) - rebalance_frequency, rebalance_frequency):+ try:+ # Training window+ train_prices = prices.iloc[i - lookback_period:i]++ # Create temporary engine for this window+ temp_engine = PyPortfolioOptAnalyticsEngine(self.config)+ temp_engine.load_data(train_prices)++ # Optimize portfolio+ weights = temp_engine.optimize_portfolio()+ weights_series = pd.Series(weights)+ weights_history.append(weights_series)++ # Forward period for evaluation+ forward_prices = prices.iloc[i:i + rebalance_frequency]+ forward_returns = forward_prices.pct_change().dropna()++ # Calculate portfolio returns+ portfolio_rets = (forward_returns * weights_series).sum(axis=1)+ portfolio_returns.extend(portfolio_rets.values)+ backtest_dates.extend(forward_returns.index)++ except Exception as e:+ print(f"Error at period {i}: {e}")+ continue++ # Create backtest DataFrame+ backtest_df = pd.DataFrame({+ 'date': backtest_dates,+ 'portfolio_return': portfolio_returns+ }).set_index('date')++ # Calculate performance metrics+ backtest_df['cumulative_return'] = (1 + backtest_df['portfolio_return']).cumprod()+ backtest_df['drawdown'] = (backtest_df['cumulative_return'] /+ backtest_df['cumulative_return'].expanding().max() - 1)++ # Store results+ annual_return = backtest_df['portfolio_return'].mean() * 252+ annual_vol = backtest_df['portfolio_return'].std() * np.sqrt(252)+ max_drawdown = backtest_df['drawdown'].min()+ sharpe_ratio = (annual_return - self.config.risk_free_rate) / annual_vol if annual_vol > 0 else 0++ self.backtest_results = {+ 'returns_df': backtest_df,+ 'weights_history': weights_history,+ 'annual_return': annual_return,+ 'annual_volatility': annual_vol,+ 'sharpe_ratio': sharpe_ratio,+ 'max_drawdown': max_drawdown,+ 'calmar_ratio': annual_return / abs(max_drawdown) if max_drawdown < 0 else 0+ }++ return backtest_df+++def risk_decomposition(self, weights: pd.Series = None) -> Dict[str, pd.Series]:+ """+ Decompose portfolio risk by asset contribution++ Parameters:+ -----------+ weights : pd.Series+ Portfolio weights++ Returns:+ --------+ Dictionary with risk decomposition+ """+ weights = weights if weights is not None else pd.Series(self.weights)++ if self.risk_model is None:+ self.calculate_risk_model()++ # Portfolio volatility+ portfolio_vol = np.sqrt(weights.T @ self.risk_model @ weights)++ # Marginal contribution to risk+ marginal_contrib = self.risk_model @ weights / portfolio_vol++ # Component contribution to risk+ component_contrib = weights * marginal_contrib++ # Percentage contribution+ pct_contrib = component_contrib / portfolio_vol * 100++ return {+ 'marginal_contribution': marginal_contrib,+ 'component_contribution': component_contrib,+ 'percentage_contribution': pct_contrib,+ 'portfolio_volatility': portfolio_vol+ }+++def sensitivity_analysis(self, parameter: str = "risk_free_rate",+ values: List[float] = None) -> pd.DataFrame:+ """+ Perform sensitivity analysis on parameters++ Parameters:+ -----------+ parameter : str+ Parameter to vary+ values : List[float]+ Values to test++ Returns:+ --------+ DataFrame with sensitivity results+ """+ if values is None:+ if parameter == "risk_free_rate":+ values = [0.0, 0.01, 0.02, 0.03, 0.04, 0.05]+ elif parameter == "risk_aversion":+ values = [0.5, 1.0, 2.0, 3.0, 5.0]+ elif parameter == "gamma":+ values = [0.0, 0.1, 0.5, 1.0, 2.0]+ else:+ raise ValueError(f"Unknown parameter: {parameter}")++ results = []+ original_value = getattr(self.config, parameter)++ for value in values:+ try:+ # Set parameter value+ setattr(self.config, parameter, value)++ # Optimize+ weights = self.optimize_portfolio()+ ret, vol, sharpe = self.portfolio_performance()++ results.append({+ parameter: value,+ 'expected_return': ret,+ 'volatility': vol,+ 'sharpe_ratio': sharpe,+ 'max_weight': max(weights.values()),+ 'min_weight': min(weights.values()),+ 'num_active_assets': sum(1 for w in weights.values() if abs(w) > 0.001)+ })++ except Exception as e:+ print(f"Error for {parameter}={value}: {e}")++ # Restore original value+ setattr(self.config, parameter, original_value)++ return pd.DataFrame(results)+++def plot_weights(self, weights: pd.Series = None, top_n: int = 15) -> go.Figure:+ """Plot portfolio weights"""+ weights = weights if weights is not None else pd.Series(self.weights)++ # Sort by absolute weight+ weights_sorted = weights.reindex(weights.abs().sort_values(ascending=False).index)[:top_n]++ # Create bar chart+ fig = go.Figure()++ colors = ['red' if w < 0 else 'blue' for w in weights_sorted.values]++ fig.add_trace(go.Bar(+ x=weights_sorted.index,+ y=weights_sorted.values,+ marker_color=colors,+ text=[f'{w:.2%}' for w in weights_sorted.values],+ textposition='outside'+ ))++ fig.update_layout(+ title=f'Portfolio Weights - {self.config.optimization_method.title()}',+ xaxis_title='Assets',+ yaxis_title='Weight',+ yaxis_tickformat='.1%',+ height=600+ )++ return fig+++def plot_efficient_frontier(self) -> go.Figure:+ """Plot efficient frontier"""+ if not self.efficient_frontier_data:+ print("Generating efficient frontier...")+ self.generate_efficient_frontier()++ frontier_data = self.efficient_frontier_data++ fig = go.Figure()++ # Plot efficient frontier+ fig.add_trace(go.Scatter(+ x=frontier_data['volatility'],+ y=frontier_data['returns'],+ mode='lines+markers',+ name='Efficient Frontier',+ line=dict(color='blue', width=2),+ marker=dict(size=4)+ ))++ # Add optimal portfolio if available+ if self.weights is not None:+ ret, vol, sharpe = self.portfolio_performance()++ fig.add_trace(go.Scatter(+ x=[vol],+ y=[ret],+ mode='markers',+ name=f'Optimal Portfolio (Sharpe: {sharpe:.2f})',+ marker=dict(color='red', size=12, symbol='star')+ ))++ fig.update_layout(+ title='Efficient Frontier',+ xaxis_title='Volatility (Risk)',+ yaxis_title='Expected Return',+ xaxis_tickformat='.1%',+ yaxis_tickformat='.1%',+ height=600+ )++ return fig+++def plot_risk_decomposition(self) -> go.Figure:+ """Plot risk decomposition"""+ if self.weights is None:+ raise ValueError("No weights available. Run optimization first.")++ risk_decomp = self.risk_decomposition()+ pct_contrib = risk_decomp['percentage_contribution']++ # Sort by contribution+ pct_contrib_sorted = pct_contrib.reindex(pct_contrib.abs().sort_values(ascending=False).index)++ fig = go.Figure()++ colors = ['red' if c < 0 else 'green' for c in pct_contrib_sorted.values]++ fig.add_trace(go.Bar(+ x=pct_contrib_sorted.index,+ y=pct_contrib_sorted.values,+ marker_color=colors,+ text=[f'{c:.1f}%' for c in pct_contrib_sorted.values],+ textposition='outside'+ ))++ fig.update_layout(+ title='Risk Contribution by Asset',+ xaxis_title='Assets',+ yaxis_title='Risk Contribution (%)',+ height=600+ )++ return fig+++def plot_backtest_results(self) -> go.Figure:+ """Plot backtest results"""+ if not self.backtest_results:+ raise ValueError("No backtest results. Run backtest_strategy() first.")++ df = self.backtest_results['returns_df']++ # Create subplots+ fig = make_subplots(+ rows=2, cols=1,+ subplot_titles=['Cumulative Returns', 'Drawdown'],+ vertical_spacing=0.1+ )++ # Cumulative returns+ fig.add_trace(+ go.Scatter(x=df.index, y=df['cumulative_return'],+ name='Portfolio', line=dict(color='blue')),+ row=1, col=1+ )++ # Drawdown+ fig.add_trace(+ go.Scatter(x=df.index, y=df['drawdown'] * 100,+ name='Drawdown', fill='tonexty',+ line=dict(color='red')),+ row=2, col=1+ )++ fig.update_layout(+ height=800,+ title=f'Backtest Results - Sharpe: {self.backtest_results["sharpe_ratio"]:.2f}'+ )+ fig.update_yaxes(tickformat='.1%', row=1, col=1)+ fig.update_yaxes(title_text="Drawdown (%)", row=2, col=1)++ return fig+++def plot_correlation_matrix(self) -> go.Figure:+ """Plot correlation matrix heatmap"""+ correlation_matrix = self.returns.corr()++ fig = go.Figure(data=go.Heatmap(+ z=correlation_matrix.values,+ x=correlation_matrix.columns,+ y=correlation_matrix.columns,+ colorscale='RdBu',+ zmid=0,+ text=correlation_matrix.round(2).values,+ texttemplate='%{text}',+ textfont={'size': 10}+ ))++ fig.update_layout(+ title='Asset Correlation Matrix',+ height=800,+ width=800+ )++ return fig+++def generate_report(self) -> Dict[str, Any]:+ """Generate comprehensive portfolio report"""+ if self.weights is None:+ raise ValueError("No optimization results available")++ # Get performance metrics+ ret, vol, sharpe = self.portfolio_performance()++ report = {+ 'timestamp': datetime.now().isoformat(),+ 'configuration': {+ 'optimization_method': self.config.optimization_method,+ 'objective': self.config.objective,+ 'expected_returns_method': self.config.expected_returns_method,+ 'risk_model_method': self.config.risk_model_method,+ 'risk_free_rate': self.config.risk_free_rate+ },+ 'portfolio_weights': dict(self.weights),+ 'performance_metrics': {+ 'expected_annual_return': ret,+ 'annual_volatility': vol,+ 'sharpe_ratio': sharpe+ },+ 'portfolio_composition': {+ 'number_of_assets': len([w for w in self.weights.values() if abs(w) > 0.001]),+ 'max_weight': max(self.weights.values()),+ 'min_weight': min(self.weights.values()),+ 'weight_sum': sum(self.weights.values()),+ 'long_positions': len([w for w in self.weights.values() if w > 0.001]),+ 'short_positions': len([w for w in self.weights.values() if w < -0.001])+ }+ }++ # Add discrete allocation if available+ if self.discrete_allocation:+ report['discrete_allocation'] = self.discrete_allocation++ # Add backtest results if available+ if self.backtest_results:+ report['backtest_performance'] = {+ 'annual_return': self.backtest_results['annual_return'],+ 'annual_volatility': self.backtest_results['annual_volatility'],+ 'sharpe_ratio': self.backtest_results['sharpe_ratio'],+ 'max_drawdown': self.backtest_results['max_drawdown'],+ 'calmar_ratio': self.backtest_results['calmar_ratio']+ }++ return report+++def save_report(self, filename: str = None) -> str:+ """Save report to JSON file"""+ if filename is None:+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ filename = f"pypfopt_report_{timestamp}.json"++ report = self.generate_report()++ with open(filename, 'w') as f:+ json.dump(report, f, indent=2, default=str)++ print(f"Report saved to: {filename}")+ return filename+++def export_weights(self, filename: str = None) -> str:+ """Export weights to CSV"""+ if self.weights is None:+ raise ValueError("No weights available to export")++ if filename is None:+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ filename = f"pypfopt_weights_{timestamp}.csv"++ weights_df = pd.DataFrame({+ 'Asset': list(self.weights.keys()),+ 'Weight': list(self.weights.values()),+ 'Weight_Percent': [w * 100 for w in self.weights.values()]+ }).sort_values('Weight', key=abs, ascending=False)++ weights_df.to_csv(filename, index=False)+ print(f"Weights exported to: {filename}")+ return filename+++# Example usage and demonstration functions+def create_sample_pypfopt_config() -> PyPortfolioOptConfig:+ """Create sample configuration for PyPortfolioOpt"""+ return PyPortfolioOptConfig(+ optimization_method="efficient_frontier",+ objective="max_sharpe",+ expected_returns_method="mean_historical_return",+ risk_model_method="sample_cov",+ risk_free_rate=0.02,+ weight_bounds=(0, 0.4), # Max 40% in any single asset+ gamma=0.1, # Small L2 regularization+ total_portfolio_value=100000+ )+++def demo_pypfopt_analytics():+ """Demonstration of PyPortfolioOpt analytics engine"""+ print("=== PyPortfolioOpt Portfolio Analytics Demo ===\n")++ # Create sample data+ import yfinance as yf++ # Sample assets - diversified portfolio+ assets = ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA', 'JPM', 'JNJ', 'PG', 'XOM', 'GLD']++ try:+ # Download data+ print("Downloading sample data...")+ prices = yf.download(assets, start='2018-01-01', end='2023-12-31')['Adj Close']++ except:+ # Create synthetic data if yfinance fails+ print("Creating synthetic data...")+ np.random.seed(42)+ dates = pd.date_range('2018-01-01', '2023-12-31', freq='D')+ n_assets = len(assets)++ # Generate correlated returns+ correlation_matrix = np.random.uniform(0.1, 0.7, (n_assets, n_assets))+ np.fill_diagonal(correlation_matrix, 1.0)+ correlation_matrix = (correlation_matrix + correlation_matrix.T) / 2++ returns = pd.DataFrame(+ np.random.multivariate_normal(+ np.random.uniform(0.0005, 0.0015, n_assets),+ correlation_matrix * 0.0004,+ len(dates)+ ),+ index=dates,+ columns=assets+ )++ # Convert to prices+ prices = (1 + returns).cumprod() * 100++ # Create configuration+ config = create_sample_pypfopt_config()++ # Initialize engine+ engine = PyPortfolioOptAnalyticsEngine(config)+ engine.load_data(prices)++ print(f"Data loaded: {len(prices)} periods, {len(prices.columns)} assets\n")++ # Standard efficient frontier optimization+ print("Performing Max Sharpe optimization...")+ weights = engine.optimize_portfolio()+ ret, vol, sharpe = engine.portfolio_performance()diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/base_calculator.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/base_calculator.pynew file mode 100644index 000000000..b5bf07777--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/base_calculator.py@@ -0,0 +1,468 @@++Quantitative Base Calculator Module+=================================++Base calculations for quantitative analysis++===== DATA SOURCES REQUIRED =====+INPUT:+ - High-frequency market data and price series+ - Order book data and market microstructure+ - Alternative data sources and sentiment indicators+ - Economic data and market fundamentals+ - Historical factor returns and premiums++OUTPUT:+ - Quantitative trading signals and strategies+ - Factor model implementations and analysis+ - Risk models and portfolio construction methods+ - Backtest results and performance attribution+ - Alpha generation and research insights++PARAMETERS:+ - factor_model: Factor model type (default: 'fama_french_5')+ - lookback_period: Historical lookback window (default: 252 days)+ - rebalance_frequency: Strategy rebalancing frequency (default: 'monthly')+ - universe_size: Investment universe size (default: 1000)+ - risk_model: Risk model for portfolio construction (default: 'barra')+++import numpy as np+import pandas as pd+from abc import ABC, abstractmethod+from typing import Union, Dict, List, Any, Optional, Tuple+import logging+from datetime import datetime+import warnings+++class BaseCalculator(ABC):+ """+ Abstract base class for all quantitative calculations.++ Provides common functionality, validation, and standardized interfaces+ for all quantitative analysis modules in Fincept Terminal.+ """++ def __init__(self, precision: int = 6, risk_free_rate: float = 0.0):+ """+ Initialize base calculator with common parameters.++ Args:+ precision: Number of decimal places for calculations+ risk_free_rate: Default risk-free rate for calculations+ """+ self.precision = precision+ self.risk_free_rate = risk_free_rate+ self.logger = self._setup_logger()+ self.calculation_metadata = {}++ def _setup_logger(self) -> logging.Logger:+ """Setup logger for the calculator."""+ logger = logging.getLogger(f"{self.__class__.__name__}")+ logger.setLevel(logging.INFO)+ return logger++ def _validate_numeric_input(self, data: Any, name: str = "data") -> Union[float, np.ndarray, pd.Series]:+ """+ Validate and convert input to appropriate numeric type.++ Args:+ data: Input data to validate+ name: Name of the parameter for error messages++ Returns:+ Validated numeric data++ Raises:+ ValueError: If data cannot be converted to numeric+ """+ if data is None:+ raise ValueError(f"{name} cannot be None")++ # Handle different input types+ if isinstance(data, (int, float)):+ if np.isnan(data) or np.isinf(data):+ raise ValueError(f"{name} contains invalid values (NaN or Inf)")+ return float(data)++ elif isinstance(data, (list, tuple)):+ try:+ arr = np.array(data, dtype=float)+ if np.any(np.isnan(arr)) or np.any(np.isinf(arr)):+ raise ValueError(f"{name} contains invalid values (NaN or Inf)")+ return arr+ except (ValueError, TypeError):+ raise ValueError(f"{name} cannot be converted to numeric array")++ elif isinstance(data, np.ndarray):+ if not np.issubdtype(data.dtype, np.number):+ raise ValueError(f"{name} must be numeric")+ if np.any(np.isnan(data)) or np.any(np.isinf(data)):+ raise ValueError(f"{name} contains invalid values (NaN or Inf)")+ return data.astype(float)++ elif isinstance(data, pd.Series):+ if not pd.api.types.is_numeric_dtype(data):+ raise ValueError(f"{name} must be numeric")+ if data.isna().any():+ warnings.warn(f"{name} contains NaN values, they will be dropped")+ data = data.dropna()+ return data.astype(float)++ elif isinstance(data, pd.DataFrame):+ if data.empty:+ raise ValueError(f"{name} DataFrame is empty")+ # Convert all columns to numeric if possible+ try:+ numeric_data = data.select_dtypes(include=[np.number])+ if numeric_data.empty:+ raise ValueError(f"{name} DataFrame has no numeric columns")+ return numeric_data.astype(float)+ except Exception:+ raise ValueError(f"{name} DataFrame cannot be converted to numeric")++ else:+ raise ValueError(f"{name} must be numeric (int, float, list, array, or pandas Series/DataFrame)")++ def _validate_positive(self, value: Union[float, np.ndarray], name: str = "value") -> Union[float, np.ndarray]:+ """+ Validate that value(s) are positive.++ Args:+ value: Value(s) to validate+ name: Name of the parameter for error messages++ Returns:+ Validated positive value(s)+ """+ validated = self._validate_numeric_input(value, name)++ if isinstance(validated, (int, float)):+ if validated <= 0:+ raise ValueError(f"{name} must be positive, got {validated}")+ else:+ if np.any(validated <= 0):+ raise ValueError(f"{name} must be positive for all values")++ return validated++ def _validate_probability(self, prob: Union[float, np.ndarray], name: str = "probability") -> Union[+ float, np.ndarray]:+ """+ Validate that probability value(s) are between 0 and 1.++ Args:+ prob: Probability value(s) to validate+ name: Name of the parameter for error messages++ Returns:+ Validated probability value(s)+ """+ validated = self._validate_numeric_input(prob, name)++ if isinstance(validated, (int, float)):+ if not 0 <= validated <= 1:+ raise ValueError(f"{name} must be between 0 and 1, got {validated}")+ else:+ if np.any((validated < 0) | (validated > 1)):+ raise ValueError(f"{name} must be between 0 and 1 for all values")++ return validated++ def _validate_returns(self, returns: Union[List, np.ndarray, pd.Series], name: str = "returns") -> np.ndarray:+ """+ Validate return data and convert to numpy array.++ Args:+ returns: Return data to validate+ name: Name of the parameter for error messages++ Returns:+ Validated returns as numpy array+ """+ validated = self._validate_numeric_input(returns, name)++ if isinstance(validated, (int, float)):+ raise ValueError(f"{name} must be a sequence of returns, not a single value")++ # Convert to numpy array+ if isinstance(validated, pd.Series):+ return validated.values+ elif isinstance(validated, pd.DataFrame):+ if validated.shape[1] == 1:+ return validated.iloc[:, 0].values+ else:+ raise ValueError(f"{name} DataFrame must have exactly one column for return calculations")++ return np.array(validated)++ def _round_result(self, result: Union[float, np.ndarray, Dict]) -> Union[float, np.ndarray, Dict]:+ """+ Round result to specified precision.++ Args:+ result: Result to round++ Returns:+ Rounded result+ """+ if isinstance(result, (int, float)):+ return round(result, self.precision)+ elif isinstance(result, np.ndarray):+ return np.round(result, self.precision)+ elif isinstance(result, dict):+ return {k: self._round_result(v) if isinstance(v, (int, float, np.ndarray)) else v+ for k, v in result.items()}+ else:+ return result++ def _create_result_dict(self,+ value: Union[float, np.ndarray],+ method: str,+ parameters: Dict[str, Any] = None,+ metadata: Dict[str, Any] = None) -> Dict[str, Any]:+ """+ Create standardized result dictionary.++ Args:+ value: Calculated value+ method: Method used for calculation+ parameters: Parameters used in calculation+ metadata: Additional metadata++ Returns:+ Standardized result dictionary+ """+ result = {+ 'value': self._round_result(value),+ 'method': method,+ 'timestamp': datetime.now().isoformat(),+ 'calculator': self.__class__.__name__+ }++ if parameters:+ result['parameters'] = parameters++ if metadata:+ result['metadata'] = metadata++ return result++ def _check_data_length(self, data: Union[np.ndarray, pd.Series], min_length: int = 2) -> None:+ """+ Check if data has sufficient length for calculations.++ Args:+ data: Data to check+ min_length: Minimum required length++ Raises:+ ValueError: If data length is insufficient+ """+ if len(data) < min_length:+ raise ValueError(f"Insufficient data: need at least {min_length} observations, got {len(data)}")++ def _handle_missing_data(self,+ data: Union[np.ndarray, pd.Series],+ method: str = 'drop') -> Union[np.ndarray, pd.Series]:+ """+ Handle missing data in input.++ Args:+ data: Input data+ method: Method to handle missing data ('drop', 'interpolate', 'forward_fill')++ Returns:+ Data with missing values handled+ """+ if isinstance(data, pd.Series):+ if method == 'drop':+ return data.dropna()+ elif method == 'interpolate':+ return data.interpolate()+ elif method == 'forward_fill':+ return data.fillna(method='ffill')+ else:+ raise ValueError(f"Unknown missing data method: {method}")++ elif isinstance(data, np.ndarray):+ if method == 'drop':+ return data[~np.isnan(data)]+ else:+ # Convert to pandas for more sophisticated handling+ series = pd.Series(data)+ return self._handle_missing_data(series, method).values++ return data++ def set_precision(self, precision: int) -> None:+ """Set calculation precision."""+ if precision < 0:+ raise ValueError("Precision must be non-negative")+ self.precision = precision++ def set_risk_free_rate(self, rate: float) -> None:+ """Set default risk-free rate."""+ self.risk_free_rate = self._validate_numeric_input(rate, "risk_free_rate")++ @abstractmethod+ def calculate(self, *args, **kwargs) -> Dict[str, Any]:+ """+ Abstract method for main calculation.+ Must be implemented by all subclasses.+ """+ pass++ def get_supported_methods(self) -> List[str]:+ """+ Get list of supported calculation methods.+ Should be overridden by subclasses.+ """+ return ['default']++ def validate_method(self, method: str) -> str:+ """+ Validate that the specified method is supported.++ Args:+ method: Method to validate++ Returns:+ Validated method name++ Raises:+ ValueError: If method is not supported+ """+ supported = self.get_supported_methods()+ if method not in supported:+ raise ValueError(f"Method '{method}' not supported. Available methods: {supported}")+ return method+++class CalculatorFactory:+ """+ Factory class for creating calculator instances.+ Provides a centralized way to instantiate different calculators.+ """++ _calculators = {}++ @classmethod+ def register_calculator(cls, name: str, calculator_class: type) -> None:+ """Register a calculator class."""+ cls._calculators[name] = calculator_class++ @classmethod+ def create_calculator(cls, name: str, **kwargs) -> BaseCalculator:+ """Create a calculator instance."""+ if name not in cls._calculators:+ raise ValueError(f"Calculator '{name}' not registered")+ return cls._calculators[name](**kwargs)++ @classmethod+ def list_calculators(cls) -> List[str]:+ """List all registered calculators."""+ return list(cls._calculators.keys())+++class CalculationResult:+ """+ Wrapper class for calculation results with additional functionality.+ """++ def __init__(self, result_dict: Dict[str, Any]):+ """Initialize with result dictionary."""+ self._data = result_dict+ self.value = result_dict.get('value')+ self.method = result_dict.get('method')+ self.timestamp = result_dict.get('timestamp')+ self.calculator = result_dict.get('calculator')++ def __repr__(self) -> str:+ return f"CalculationResult(value={self.value}, method='{self.method}')"++ def __float__(self) -> float:+ """Allow conversion to float."""+ if isinstance(self.value, (int, float)):+ return float(self.value)+ raise TypeError("Cannot convert array result to float")++ def to_dict(self) -> Dict[str, Any]:+ """Return result as dictionary."""+ return self._data.copy()++ def to_dataframe(self) -> pd.DataFrame:+ """Convert result to DataFrame if applicable."""+ if isinstance(self.value, np.ndarray):+ return pd.DataFrame({'value': self.value})+ else:+ return pd.DataFrame([self._data])++ def export_json(self, filepath: str) -> None:+ """Export result to JSON file."""+ import json+ with open(filepath, 'w') as f:+ # Handle numpy arrays in JSON serialization+ def convert_numpy(obj):+ if isinstance(obj, np.ndarray):+ return obj.tolist()+ elif isinstance(obj, np.integer):+ return int(obj)+ elif isinstance(obj, np.floating):+ return float(obj)+ raise TypeError(f"Object of type {type(obj)} is not JSON serializable")++ json.dump(self._data, f, default=convert_numpy, indent=2)+++# Decorators for common functionality+def validate_inputs(func):+ """Decorator to add input validation to calculation methods."""++ def wrapper(self, *args, **kwargs):+ try:+ return func(self, *args, **kwargs)+ except Exception as e:+ self.logger.error(f"Error in {func.__name__}: {str(e)}")+ raise++ return wrapper+++def cache_result(func):+ """Decorator to cache calculation results."""++ def wrapper(self, *args, **kwargs):+ # Simple caching based on function arguments+ cache_key = f"{func.__name__}_{hash(str(args) + str(sorted(kwargs.items())))}"++ if not hasattr(self, '_cache'):+ self._cache = {}++ if cache_key in self._cache:+ self.logger.info(f"Returning cached result for {func.__name__}")+ return self._cache[cache_key]++ result = func(self, *args, **kwargs)+ self._cache[cache_key] = result+ return result++ return wrapper+++def timing_decorator(func):+ """Decorator to measure calculation time."""++ def wrapper(self, *args, **kwargs):+ import time+ start_time = time.time()+ result = func(self, *args, **kwargs)+ end_time = time.time()++ if isinstance(result, dict):+ result['calculation_time'] = round(end_time - start_time, 4)++ return result++ return wrapper\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/data_validator.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/data_validator.pynew file mode 100644index 000000000..52b4b4ff5--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/data_validator.py@@ -0,0 +1,843 @@++Quantitative Data Validator Module+=================================++Data validation for quantitative models++===== DATA SOURCES REQUIRED =====+INPUT:+ - High-frequency market data and price series+ - Order book data and market microstructure+ - Alternative data sources and sentiment indicators+ - Economic data and market fundamentals+ - Historical factor returns and premiums++OUTPUT:+ - Quantitative trading signals and strategies+ - Factor model implementations and analysis+ - Risk models and portfolio construction methods+ - Backtest results and performance attribution+ - Alpha generation and research insights++PARAMETERS:+ - factor_model: Factor model type (default: 'fama_french_5')+ - lookback_period: Historical lookback window (default: 252 days)+ - rebalance_frequency: Strategy rebalancing frequency (default: 'monthly')+ - universe_size: Investment universe size (default: 1000)+ - risk_model: Risk model for portfolio construction (default: 'barra')+++import numpy as np+import pandas as pd+from typing import Union, Dict, List, Any, Optional, Tuple, Callable+import warnings+from datetime import datetime, timedelta+from scipy import stats+import re+++class DataQualityReport:+ """+ Comprehensive data quality assessment report.+ """++ def __init__(self, data_name: str):+ """Initialize data quality report."""+ self.data_name = data_name+ self.timestamp = datetime.now()+ self.issues = []+ self.warnings = []+ self.statistics = {}+ self.recommendations = []+ self.quality_score = 100.0++ def add_issue(self, issue_type: str, description: str, severity: str = 'medium'):+ """Add a data quality issue."""+ self.issues.append({+ 'type': issue_type,+ 'description': description,+ 'severity': severity,+ 'timestamp': datetime.now()+ })++ # Reduce quality score based on severity+ score_reduction = {'low': 5, 'medium': 10, 'high': 20, 'critical': 50}+ self.quality_score -= score_reduction.get(severity, 10)+ self.quality_score = max(0, self.quality_score)++ def add_warning(self, warning_type: str, message: str):+ """Add a warning."""+ self.warnings.append({+ 'type': warning_type,+ 'message': message,+ 'timestamp': datetime.now()+ })++ def add_recommendation(self, recommendation: str):+ """Add a recommendation for improvement."""+ self.recommendations.append(recommendation)++ def to_dict(self) -> Dict[str, Any]:+ """Convert report to dictionary."""+ return {+ 'data_name': self.data_name,+ 'timestamp': self.timestamp.isoformat(),+ 'quality_score': round(self.quality_score, 2),+ 'issues': self.issues,+ 'warnings': self.warnings,+ 'statistics': self.statistics,+ 'recommendations': self.recommendations+ }++ def print_summary(self):+ """Print a summary of the data quality report."""+ print(f"\n=== Data Quality Report: {self.data_name} ===")+ print(f"Quality Score: {self.quality_score:.1f}/100")+ print(f"Issues Found: {len(self.issues)}")+ print(f"Warnings: {len(self.warnings)}")++ if self.issues:+ print("\nCritical Issues:")+ for issue in self.issues:+ if issue['severity'] in ['high', 'critical']:+ print(f" - {issue['description']}")++ if self.recommendations:+ print("\nRecommendations:")+ for rec in self.recommendations[:3]: # Show top 3+ print(f" - {rec}")+++class DataValidator:+ """+ Comprehensive data validation and quality control system.+ """++ def __init__(self, strict_mode: bool = False):+ """+ Initialize data validator.++ Args:+ strict_mode: If True, raises exceptions for quality issues+ """+ self.strict_mode = strict_mode+ self.validation_rules = {}+ self._setup_default_rules()++ def _setup_default_rules(self):+ """Setup default validation rules."""+ self.validation_rules = {+ 'min_observations': 2,+ 'max_missing_ratio': 0.1,+ 'outlier_std_threshold': 3.0,+ 'min_numeric_ratio': 0.95,+ 'date_format_patterns': [+ '%Y-%m-%d', '%m/%d/%Y', '%d/%m/%Y',+ '%Y-%m-%d %H:%M:%S', '%m/%d/%Y %H:%M:%S'+ ]+ }++ def validate_financial_data(self,+ data: Union[pd.DataFrame, pd.Series, np.ndarray, List],+ data_type: str = 'general',+ data_name: str = 'data') -> Tuple[Any, DataQualityReport]:+ """+ Comprehensive validation of financial data.++ Args:+ data: Input data to validate+ data_type: Type of financial data ('returns', 'prices', 'rates', 'general')+ data_name: Name for reporting purposes++ Returns:+ Tuple of (cleaned_data, quality_report)+ """+ report = DataQualityReport(data_name)++ try:+ # Convert to pandas for easier manipulation+ if isinstance(data, (list, tuple)):+ data = pd.Series(data)+ elif isinstance(data, np.ndarray):+ if data.ndim == 1:+ data = pd.Series(data)+ else:+ data = pd.DataFrame(data)++ # Basic structure validation+ cleaned_data = self._validate_structure(data, report)++ # Data type specific validation+ if data_type == 'returns':+ cleaned_data = self._validate_returns(cleaned_data, report)+ elif data_type == 'prices':+ cleaned_data = self._validate_prices(cleaned_data, report)+ elif data_type == 'rates':+ cleaned_data = self._validate_rates(cleaned_data, report)++ # General quality checks+ self._check_data_quality(cleaned_data, report)++ # Generate recommendations+ self._generate_recommendations(cleaned_data, report)++ return cleaned_data, report++ except Exception as e:+ report.add_issue('validation_error', f"Validation failed: {str(e)}", 'critical')+ if self.strict_mode:+ raise+ return data, report++ def _validate_structure(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport) -> Union[+ pd.DataFrame, pd.Series]:+ """Validate basic data structure."""++ # Check if data is empty+ if len(data) == 0:+ report.add_issue('empty_data', 'Dataset is empty', 'critical')+ if self.strict_mode:+ raise ValueError("Dataset is empty")++ # Check minimum observations+ if len(data) < self.validation_rules['min_observations']:+ report.add_issue('insufficient_data',+ f"Only {len(data)} observations, minimum {self.validation_rules['min_observations']} required",+ 'high')++ # Check for duplicates in index (if pandas)+ if isinstance(data, (pd.DataFrame, pd.Series)):+ if data.index.duplicated().any():+ report.add_warning('duplicate_index', 'Duplicate index values found')+ data = data.loc[~data.index.duplicated(keep='first')]++ report.statistics['total_observations'] = len(data)+ return data++ def _validate_returns(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport) -> Union[+ pd.DataFrame, pd.Series]:+ """Validate return data specifically."""++ if isinstance(data, pd.DataFrame):+ numeric_data = data.select_dtypes(include=[np.number])+ else:+ numeric_data = data++ # Check for extreme returns (potential data errors)+ if isinstance(numeric_data, pd.DataFrame):+ for col in numeric_data.columns:+ extreme_returns = numeric_data[col].abs() > 1.0 # >100% returns+ if extreme_returns.any():+ count = extreme_returns.sum()+ report.add_warning('extreme_returns',+ f"Column {col}: {count} returns > 100% found")+ else:+ extreme_returns = numeric_data.abs() > 1.0+ if extreme_returns.any():+ count = extreme_returns.sum()+ report.add_warning('extreme_returns', f"{count} returns > 100% found")++ # Check for return patterns that might indicate data issues+ self._check_return_patterns(numeric_data, report)++ return data++ def _validate_prices(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport) -> Union[+ pd.DataFrame, pd.Series]:+ """Validate price data specifically."""++ if isinstance(data, pd.DataFrame):+ numeric_data = data.select_dtypes(include=[np.number])+ else:+ numeric_data = data++ # Check for negative prices+ if isinstance(numeric_data, pd.DataFrame):+ for col in numeric_data.columns:+ negative_prices = numeric_data[col] <= 0+ if negative_prices.any():+ count = negative_prices.sum()+ report.add_issue('negative_prices',+ f"Column {col}: {count} non-positive prices found", 'high')+ else:+ negative_prices = numeric_data <= 0+ if negative_prices.any():+ count = negative_prices.sum()+ report.add_issue('negative_prices', f"{count} non-positive prices found", 'high')++ # Check for price jumps (potential stock splits or data errors)+ self._check_price_jumps(numeric_data, report)++ return data++ def _validate_rates(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport) -> Union[+ pd.DataFrame, pd.Series]:+ """Validate interest rate data specifically."""++ if isinstance(data, pd.DataFrame):+ numeric_data = data.select_dtypes(include=[np.number])+ else:+ numeric_data = data++ # Check for unrealistic rates+ if isinstance(numeric_data, pd.DataFrame):+ for col in numeric_data.columns:+ high_rates = numeric_data[col] > 1.0 # >100% rates+ if high_rates.any():+ count = high_rates.sum()+ report.add_warning('high_rates',+ f"Column {col}: {count} rates > 100% found")+ else:+ high_rates = numeric_data > 1.0+ if high_rates.any():+ count = high_rates.sum()+ report.add_warning('high_rates', f"{count} rates > 100% found")++ return data++ def _check_data_quality(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Perform general data quality checks."""++ # Missing data analysis+ self._analyze_missing_data(data, report)++ # Outlier detection+ self._detect_outliers(data, report)++ # Data type consistency+ self._check_data_types(data, report)++ # Statistical summaries+ self._generate_statistics(data, report)++ def _analyze_missing_data(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Analyze missing data patterns."""++ if isinstance(data, pd.DataFrame):+ total_cells = data.size+ missing_cells = data.isna().sum().sum()+ missing_ratio = missing_cells / total_cells if total_cells > 0 else 0++ # Column-wise missing data+ missing_by_column = data.isna().sum()+ for col, missing_count in missing_by_column.items():+ if missing_count > 0:+ col_ratio = missing_count / len(data)+ if col_ratio > self.validation_rules['max_missing_ratio']:+ report.add_issue('high_missing_data',+ f"Column {col}: {col_ratio:.1%} missing data", 'medium')++ else: # Series+ missing_count = data.isna().sum()+ missing_ratio = missing_count / len(data) if len(data) > 0 else 0++ if missing_ratio > self.validation_rules['max_missing_ratio']:+ report.add_issue('high_missing_data',+ f"{missing_ratio:.1%} missing data", 'medium')++ report.statistics['missing_data_ratio'] = round(missing_ratio, 4)++ def _detect_outliers(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Detect statistical outliers."""++ def detect_outliers_series(series: pd.Series, name: str = ''):+ if not pd.api.types.is_numeric_dtype(series):+ return++ clean_series = series.dropna()+ if len(clean_series) < 3:+ return++ # Z-score method+ z_scores = np.abs(stats.zscore(clean_series))+ outliers_zscore = z_scores > self.validation_rules['outlier_std_threshold']++ # IQR method+ Q1 = clean_series.quantile(0.25)+ Q3 = clean_series.quantile(0.75)+ IQR = Q3 - Q1+ outliers_iqr = (clean_series < (Q1 - 1.5 * IQR)) | (clean_series > (Q3 + 1.5 * IQR))++ # Report outliers+ outlier_count_z = outliers_zscore.sum()+ outlier_count_iqr = outliers_iqr.sum()++ if outlier_count_z > 0:+ report.add_warning('outliers_zscore',+ f"{name}Z-score outliers detected: {outlier_count_z}")++ if outlier_count_iqr > 0:+ report.add_warning('outliers_iqr',+ f"{name}IQR outliers detected: {outlier_count_iqr}")++ if isinstance(data, pd.DataFrame):+ numeric_cols = data.select_dtypes(include=[np.number]).columns+ for col in numeric_cols:+ detect_outliers_series(data[col], f"Column {col}: ")+ else:+ detect_outliers_series(data)++ def _check_data_types(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Check data type consistency."""++ if isinstance(data, pd.DataFrame):+ numeric_cols = data.select_dtypes(include=[np.number]).columns+ total_cols = len(data.columns)+ numeric_ratio = len(numeric_cols) / total_cols if total_cols > 0 else 0++ if numeric_ratio < self.validation_rules['min_numeric_ratio']:+ report.add_warning('low_numeric_ratio',+ f"Only {numeric_ratio:.1%} of columns are numeric")++ # Check for mixed types in columns+ for col in data.columns:+ if data[col].dtype == 'object':+ # Try to identify what type it should be+ sample = data[col].dropna().head(100)+ if self._looks_like_numeric(sample):+ report.add_issue('type_mismatch',+ f"Column {col} contains numeric data stored as text", 'medium')+ elif self._looks_like_date(sample):+ report.add_issue('type_mismatch',+ f"Column {col} contains date data stored as text", 'medium')++ report.statistics['data_types'] = data.dtypes.astype(str).to_dict() if isinstance(data, pd.DataFrame) else str(+ data.dtype)++ def _looks_like_numeric(self, sample: pd.Series) -> bool:+ """Check if text data looks like it should be numeric."""+ if len(sample) == 0:+ return False++ numeric_pattern = re.compile(r'^-?\d*\.?\d+([eE][+-]?\d+)?')+ numeric_count = sample.astype(str).str.match(numeric_pattern).sum()+ return numeric_count / len(sample) > 0.8++ def _looks_like_date(self, sample: pd.Series) -> bool:+ """Check if text data looks like it should be dates."""+ if len(sample) == 0:+ return False++ date_patterns = [+ r'\d{4}-\d{2}-\d{2}', # YYYY-MM-DD+ r'\d{2}/\d{2}/\d{4}', # MM/DD/YYYY+ r'\d{2}-\d{2}-\d{4}', # MM-DD-YYYY+ ]++ for pattern in date_patterns:+ matches = sample.astype(str).str.match(pattern).sum()+ if matches / len(sample) > 0.8:+ return True+ return False++ def _generate_statistics(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Generate comprehensive statistics for the data."""++ if isinstance(data, pd.DataFrame):+ numeric_data = data.select_dtypes(include=[np.number])+ if not numeric_data.empty:+ stats_dict = {+ 'shape': data.shape,+ 'numeric_columns': len(numeric_data.columns),+ 'total_columns': len(data.columns),+ 'memory_usage_mb': round(data.memory_usage(deep=True).sum() / (1024 ** 2), 2)+ }++ # Summary statistics for numeric columns+ desc_stats = numeric_data.describe()+ stats_dict['summary_statistics'] = desc_stats.to_dict()++ else: # Series+ if pd.api.types.is_numeric_dtype(data):+ clean_data = data.dropna()+ stats_dict = {+ 'length': len(data),+ 'non_null_count': len(clean_data),+ 'mean': float(clean_data.mean()) if len(clean_data) > 0 else None,+ 'std': float(clean_data.std()) if len(clean_data) > 1 else None,+ 'min': float(clean_data.min()) if len(clean_data) > 0 else None,+ 'max': float(clean_data.max()) if len(clean_data) > 0 else None,+ 'skewness': float(clean_data.skew()) if len(clean_data) > 2 else None,+ 'kurtosis': float(clean_data.kurtosis()) if len(clean_data) > 3 else None+ }+ else:+ stats_dict = {+ 'length': len(data),+ 'non_null_count': data.notna().sum(),+ 'unique_values': data.nunique(),+ 'data_type': str(data.dtype)+ }++ report.statistics.update(stats_dict)++ def _check_return_patterns(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Check for suspicious patterns in return data."""++ def check_series_patterns(series: pd.Series, name: str = ''):+ clean_series = series.dropna()+ if len(clean_series) < 10:+ return++ # Check for too many zeros+ zero_count = (clean_series == 0).sum()+ zero_ratio = zero_count / len(clean_series)+ if zero_ratio > 0.1:+ report.add_warning('high_zero_returns',+ f"{name}High proportion of zero returns: {zero_ratio:.1%}")++ # Check for perfect correlations (repeated patterns)+ if len(clean_series) > 20:+ # Check for repeated sequences+ for window in [5, 10]:+ if len(clean_series) >= window * 3:+ rolling_std = clean_series.rolling(window).std()+ low_variance_periods = (rolling_std < 0.001).sum()+ if low_variance_periods > len(clean_series) * 0.1:+ report.add_warning('low_variance_periods',+ f"{name}Detected periods with suspiciously low variance")++ # Check return distribution+ if len(clean_series) > 30:+ # Jarque-Bera test for normality+ try:+ jb_stat, jb_pvalue = stats.jarque_bera(clean_series)+ if jb_pvalue < 0.01:+ report.add_warning('non_normal_returns',+ f"{name}Returns significantly deviate from normal distribution")+ except:+ pass++ if isinstance(data, pd.DataFrame):+ for col in data.select_dtypes(include=[np.number]).columns:+ check_series_patterns(data[col], f"Column {col}: ")+ else:+ check_series_patterns(data)++ def _check_price_jumps(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Check for suspicious price jumps."""++ def check_series_jumps(series: pd.Series, name: str = ''):+ clean_series = series.dropna()+ if len(clean_series) < 2:+ return++ # Calculate price changes+ price_changes = clean_series.pct_change().dropna()++ # Check for large jumps (potential stock splits or errors)+ large_jumps = price_changes.abs() > 0.5 # >50% price changes+ if large_jumps.any():+ jump_count = large_jumps.sum()+ report.add_warning('large_price_jumps',+ f"{name}{jump_count} large price jumps (>50%) detected")++ # Check for exact halving or doubling (potential split/reverse split)+ halving = (price_changes > -0.55) & (price_changes < -0.45) # ~50% drop+ doubling = (price_changes > 0.95) & (price_changes < 1.05) # ~100% gain++ if halving.any() or doubling.any():+ report.add_warning('potential_splits',+ f"{name}Potential stock splits/reverse splits detected")++ if isinstance(data, pd.DataFrame):+ for col in data.select_dtypes(include=[np.number]).columns:+ check_series_jumps(data[col], f"Column {col}: ")+ else:+ check_series_jumps(data)++ def _generate_recommendations(self, data: Union[pd.DataFrame, pd.Series], report: DataQualityReport):+ """Generate data improvement recommendations."""++ # Based on issues found, suggest improvements+ issue_types = [issue['type'] for issue in report.issues]+ warning_types = [warning['type'] for warning in report.warnings]++ if 'high_missing_data' in issue_types:+ report.add_recommendation("Consider using interpolation or forward-fill for missing data")+ report.add_recommendation("Investigate the source of missing data - is it systematic?")++ if 'negative_prices' in issue_types:+ report.add_recommendation("Remove or correct negative price observations")+ report.add_recommendation("Verify data source and collection methodology")++ if 'extreme_returns' in warning_types:+ report.add_recommendation("Review extreme returns - may indicate data errors or corporate actions")+ report.add_recommendation("Consider winsorizing extreme values if confirmed as outliers")++ if 'outliers_zscore' in warning_types or 'outliers_iqr' in warning_types:+ report.add_recommendation("Investigate outliers - may be valid extreme events or data errors")+ report.add_recommendation("Consider robust statistical methods that are less sensitive to outliers")++ if 'type_mismatch' in issue_types:+ report.add_recommendation("Convert text columns to appropriate data types (numeric/datetime)")+ report.add_recommendation("Standardize data formats before importing")++ if 'insufficient_data' in issue_types:+ report.add_recommendation("Collect more historical data for reliable statistical analysis")+ report.add_recommendation("Consider using higher frequency data if available")++ if len(report.recommendations) == 0:+ report.add_recommendation("Data quality appears good - proceed with analysis")++ def clean_data(self,+ data: Union[pd.DataFrame, pd.Series],+ method: str = 'conservative',+ **kwargs) -> Union[pd.DataFrame, pd.Series]:+ """+ Clean data based on validation results.++ Args:+ data: Data to clean+ method: Cleaning method ('conservative', 'aggressive', 'custom')+ **kwargs: Additional parameters for cleaning++ Returns:+ Cleaned data+ """+ cleaned_data = data.copy()++ if method == 'conservative':+ # Only remove obvious errors+ if isinstance(cleaned_data, pd.DataFrame):+ # Remove rows where all values are NaN+ cleaned_data = cleaned_data.dropna(how='all')++ # For price data, remove negative values+ numeric_cols = cleaned_data.select_dtypes(include=[np.number]).columns+ for col in numeric_cols:+ if 'price' in col.lower():+ cleaned_data = cleaned_data[cleaned_data[col] > 0]++ else: # Series+ # Remove NaN values+ cleaned_data = cleaned_data.dropna()++ elif method == 'aggressive':+ # More thorough cleaning+ if isinstance(cleaned_data, pd.DataFrame):+ # Remove columns with >50% missing data+ missing_ratio = cleaned_data.isna().mean()+ cols_to_keep = missing_ratio[missing_ratio <= 0.5].index+ cleaned_data = cleaned_data[cols_to_keep]++ # Remove outliers using IQR method+ numeric_cols = cleaned_data.select_dtypes(include=[np.number]).columns+ for col in numeric_cols:+ Q1 = cleaned_data[col].quantile(0.25)+ Q3 = cleaned_data[col].quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - 1.5 * IQR+ upper_bound = Q3 + 1.5 * IQR++ cleaned_data = cleaned_data[+ (cleaned_data[col] >= lower_bound) &+ (cleaned_data[col] <= upper_bound)+ ]++ else: # Series+ # Remove outliers+ Q1 = cleaned_data.quantile(0.25)+ Q3 = cleaned_data.quantile(0.75)+ IQR = Q3 - Q1+ lower_bound = Q1 - 1.5 * IQR+ upper_bound = Q3 + 1.5 * IQR++ cleaned_data = cleaned_data[+ (cleaned_data >= lower_bound) &+ (cleaned_data <= upper_bound)+ ]++ return cleaned_data++ def validate_date_range(self,+ dates: Union[pd.DatetimeIndex, pd.Series, List],+ start_date: Optional[datetime] = None,+ end_date: Optional[datetime] = None) -> Tuple[bool, List[str]]:+ """+ Validate date range and continuity.++ Args:+ dates: Date data to validate+ start_date: Expected start date+ end_date: Expected end date++ Returns:+ Tuple of (is_valid, list_of_issues)+ """+ issues = []++ try:+ if isinstance(dates, list):+ dates = pd.to_datetime(dates)+ elif isinstance(dates, pd.Series):+ dates = pd.to_datetime(dates)++ # Check for duplicates+ if dates.duplicated().any():+ issues.append("Duplicate dates found")++ # Check chronological order+ if not dates.is_monotonic_increasing:+ issues.append("Dates are not in chronological order")++ # Check date range+ if start_date and dates.min() < start_date:+ issues.append(f"Data starts before expected date: {start_date}")++ if end_date and dates.max() > end_date:+ issues.append(f"Data ends after expected date: {end_date}")++ # Check for large gaps+ if len(dates) > 1:+ date_diffs = dates.to_series().diff().dropna()+ median_diff = date_diffs.median()+ large_gaps = date_diffs > median_diff * 5++ if large_gaps.any():+ gap_count = large_gaps.sum()+ issues.append(f"Found {gap_count} large gaps in date sequence")++ return len(issues) == 0, issues++ except Exception as e:+ issues.append(f"Date validation error: {str(e)}")+ return False, issues++ def validate_correlation_matrix(self,+ corr_matrix: pd.DataFrame,+ tolerance: float = 1e-6) -> Tuple[bool, List[str]]:+ """+ Validate correlation matrix properties.++ Args:+ corr_matrix: Correlation matrix to validate+ tolerance: Numerical tolerance for validation++ Returns:+ Tuple of (is_valid, list_of_issues)+ """+ issues = []++ try:+ # Check if square+ if corr_matrix.shape[0] != corr_matrix.shape[1]:+ issues.append("Correlation matrix is not square")+ return False, issues++ # Check if symmetric+ if not np.allclose(corr_matrix.values, corr_matrix.values.T, atol=tolerance):+ issues.append("Correlation matrix is not symmetric")++ # Check diagonal elements+ diagonal = np.diag(corr_matrix.values)+ if not np.allclose(diagonal, 1.0, atol=tolerance):+ issues.append("Diagonal elements are not equal to 1")++ # Check value range+ if (corr_matrix.values < -1 - tolerance).any() or (corr_matrix.values > 1 + tolerance).any():+ issues.append("Correlation values outside [-1, 1] range")++ # Check for perfect correlations (excluding diagonal)+ off_diagonal = corr_matrix.values[~np.eye(corr_matrix.shape[0], dtype=bool)]+ perfect_corrs = np.abs(off_diagonal) > (1 - tolerance)+ if perfect_corrs.any():+ issues.append("Perfect correlations detected (may indicate data issues)")++ # Check positive semi-definiteness+ eigenvals = np.linalg.eigvals(corr_matrix.values)+ if (eigenvals < -tolerance).any():+ issues.append("Correlation matrix is not positive semi-definite")++ return len(issues) == 0, issues++ except Exception as e:+ issues.append(f"Correlation matrix validation error: {str(e)}")+ return False, issues++ def validate_portfolio_weights(self,+ weights: Union[List, np.ndarray, pd.Series],+ tolerance: float = 1e-6) -> Tuple[bool, List[str]]:+ """+ Validate portfolio weights.++ Args:+ weights: Portfolio weights to validate+ tolerance: Numerical tolerance++ Returns:+ Tuple of (is_valid, list_of_issues)+ """+ issues = []++ try:+ weights = np.array(weights)++ # Check if weights sum to 1+ weights_sum = np.sum(weights)+ if not np.isclose(weights_sum, 1.0, atol=tolerance):+ issues.append(f"Weights sum to {weights_sum:.6f}, not 1.0")++ # Check for negative weights (if not allowing short selling)+ if (weights < -tolerance).any():+ negative_count = (weights < -tolerance).sum()+ issues.append(f"Found {negative_count} negative weights (short positions)")++ # Check for extremely small weights+ very_small = np.abs(weights) < tolerance+ if very_small.any():+ small_count = very_small.sum()+ issues.append(f"Found {small_count} very small weights (< {tolerance})")++ return len(issues) == 0, issues++ except Exception as e:+ issues.append(f"Portfolio weights validation error: {str(e)}")+ return False, issues+++# Utility functions for common validations+def validate_returns_series(returns: Union[List, np.ndarray, pd.Series],+ name: str = "returns") -> np.ndarray:+ """Quick validation for return series."""+ validator = DataValidator()++ if isinstance(returns, (list, tuple)):+ returns = np.array(returns)+ elif isinstance(returns, pd.Series):+ returns = returns.values++ if len(returns) < 2:+ raise ValueError(f"{name} must have at least 2 observations")++ if np.any(np.isnan(returns)) or np.any(np.isinf(returns)):+ raise ValueError(f"{name} contains invalid values (NaN or Inf)")++ return returns.astype(float)+++def validate_positive_number(value: Union[int, float], name: str = "value") -> float:+ """Quick validation for positive numbers."""+ if not isinstance(value, (int, float)):+ raise TypeError(f"{name} must be a number")++ if np.isnan(value) or np.isinf(value):+ raise ValueError(f"{name} cannot be NaN or infinite")++ if value <= 0:+ raise ValueError(f"{name} must be positive")++ return float(value)+++def validate_probability(prob: Union[int, float], name: str = "probability") -> float:+ """Quick validation for probability values."""+ if not isinstance(prob, (int, float)):+ raise TypeError(f"{name} must be a number")++ if np.isnan(prob) or np.isinf(prob):+ raise ValueError(f"{name} cannot be NaN or infinite")++ if not 0 <= prob <= 1:+ raise ValueError(f"{name} must be between 0 and 1")++ return float(prob)\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/quant_modules_3042.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/quant_modules_3042.pynew file mode 100644index 000000000..fc8949238--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/quant_modules_3042.py@@ -0,0 +1,1266 @@++Quantitative Quant Modules 3042 Module+=================================++Quantitative analysis modules and functions++===== DATA SOURCES REQUIRED =====+INPUT:+ - High-frequency market data and price series+ - Order book data and market microstructure+ - Alternative data sources and sentiment indicators+ - Economic data and market fundamentals+ - Historical factor returns and premiums++OUTPUT:+ - Quantitative trading signals and strategies+ - Factor model implementations and analysis+ - Risk models and portfolio construction methods+ - Backtest results and performance attribution+ - Alpha generation and research insights++PARAMETERS:+ - factor_model: Factor model type (default: 'fama_french_5')+ - lookback_period: Historical lookback window (default: 252 days)+ - rebalance_frequency: Strategy rebalancing frequency (default: 'monthly')+ - universe_size: Investment universe size (default: 1000)+ - risk_model: Risk model for portfolio construction (default: 'barra')+++import numpy as np+import pandas as pd+from typing import Union, Dict, List, Any, Optional, Tuple, Callable+from scipy import stats+from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV+from sklearn.preprocessing import StandardScaler, LabelEncoder+from sklearn.linear_model import Ridge, Lasso, ElasticNet+from sklearn.svm import SVC, SVR+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor+from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor+from sklearn.cluster import KMeans, AgglomerativeClustering+from sklearn.decomposition import PCA+from sklearn.metrics import classification_report, confusion_matrix, mean_squared_error, r2_score+import warnings++from .base_calculator import BaseCalculator, validate_inputs, timing_decorator+from .exceptions import handle_calculation_error, DataValidationError+++class AdvancedQuantAnalyzer(BaseCalculator):+ """Comprehensive analyzer for advanced quantitative methods."""++ def __init__(self, precision: int = 6, random_seed: Optional[int] = 42):+ super().__init__(precision)+ self.random_seed = random_seed+ if random_seed is not None:+ np.random.seed(random_seed)++ def get_supported_methods(self) -> List[str]:+ return [+ # Time Series+ 'trend_analysis', 'stationarity_test', 'arima_model', 'forecasting',+ # Machine Learning+ 'supervised_learning', 'unsupervised_learning', 'model_evaluation', 'feature_engineering',+ # Sampling+ 'sampling_techniques', 'central_limit_theorem', 'resampling_methods', 'sampling_error_analysis'+ ]++ # ========================================+ # TIME SERIES ANALYSIS METHODS+ # ========================================++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def analyze_trend(self,+ data: Union[List, np.ndarray, pd.Series],+ trend_type: str = 'linear',+ dates: Optional[pd.DatetimeIndex] = None) -> Dict[str, Any]:+ """Analyze linear and log-linear trends in time series data."""+ data = self._validate_returns(data, "data")+ self._check_data_length(data, min_length=10)++ if trend_type not in ['linear', 'log_linear']:+ raise DataValidationError(f"Invalid trend_type: {trend_type}", "trend_type")++ # Create time index+ if dates is not None:+ time_index = np.arange(len(dates))+ else:+ time_index = np.arange(len(data))++ # Prepare data for regression+ if trend_type == 'log_linear':+ if np.any(data <= 0):+ raise DataValidationError("Log-linear trend requires positive data", "data")+ y_data = np.log(data)+ else:+ y_data = data++ # Fit trend using OLS+ X = np.column_stack([np.ones(len(time_index)), time_index])+ coefficients = np.linalg.lstsq(X, y_data, rcond=None)[0]++ intercept, slope = coefficients+ fitted_values = intercept + slope * time_index+ residuals = y_data - fitted_values++ # Transform back if log-linear+ if trend_type == 'log_linear':+ fitted_values_original = np.exp(fitted_values)+ residuals_original = data - fitted_values_original+ else:+ fitted_values_original = fitted_values+ residuals_original = residuals++ # Calculate R-squared+ ss_res = np.sum(residuals ** 2)+ ss_tot = np.sum((y_data - np.mean(y_data)) ** 2)+ r_squared = 1 - (ss_res / ss_tot) if ss_tot != 0 else 0++ # Statistical tests+ n = len(data)+ mse = ss_res / (n - 2)+ var_slope = mse / np.sum((time_index - np.mean(time_index)) ** 2)+ t_stat = slope / np.sqrt(var_slope) if var_slope > 0 else np.inf+ p_value = 2 * (1 - stats.t.cdf(abs(t_stat), n - 2))++ return self._create_result_dict(+ value={'slope': slope, 'intercept': intercept},+ method=f'{trend_type}_trend',+ parameters={+ 'data': data.tolist() if hasattr(data, 'tolist') else list(data),+ 'trend_type': trend_type+ },+ metadata={+ 'fitted_values': fitted_values_original.tolist(),+ 'residuals': residuals_original.tolist(),+ 'r_squared': r_squared,+ 'slope_t_statistic': t_stat,+ 'slope_p_value': p_value,+ 'trend_significant': p_value < 0.05,+ 'trend_direction': 'upward' if slope > 0 else 'downward' if slope < 0 else 'flat'+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def test_stationarity(self,+ data: Union[List, np.ndarray, pd.Series],+ test_type: str = 'adf') -> Dict[str, Any]:+ """Test for stationarity using various unit root tests."""+ data = self._validate_returns(data, "data")+ self._check_data_length(data, min_length=20)++ if test_type not in ['adf', 'kpss', 'pp']:+ raise DataValidationError(f"Invalid test_type: {test_type}", "test_type")++ results = {}++ if test_type == 'adf':+ # Augmented Dickey-Fuller test+ from statsmodels.tsa.stattools import adfuller+ adf_result = adfuller(data, autolag='AIC')++ results = {+ 'test_statistic': adf_result[0],+ 'p_value': adf_result[1],+ 'critical_values': adf_result[4],+ 'is_stationary': adf_result[1] < 0.05,+ 'null_hypothesis': 'Unit root (non-stationary)'+ }++ elif test_type == 'kpss':+ # KPSS test+ from statsmodels.tsa.stattools import kpss+ kpss_result = kpss(data, regression='c')++ results = {+ 'test_statistic': kpss_result[0],+ 'p_value': kpss_result[1],+ 'critical_values': kpss_result[3],+ 'is_stationary': kpss_result[1] > 0.05,+ 'null_hypothesis': 'Stationary'+ }++ # Additional stationarity indicators+ rolling_mean = pd.Series(data).rolling(window=min(20, len(data) // 4)).mean()+ rolling_std = pd.Series(data).rolling(window=min(20, len(data) // 4)).std()++ return self._create_result_dict(+ value=results,+ method=f'{test_type}_stationarity_test',+ parameters={+ 'data': data.tolist() if hasattr(data, 'tolist') else list(data),+ 'test_type': test_type+ },+ metadata={+ 'rolling_mean_stability': np.std(rolling_mean.dropna()),+ 'rolling_std_stability': np.std(rolling_std.dropna()),+ 'mean_reversion_strength': abs(np.corrcoef(data[:-1], np.diff(data))[0, 1]) if len(data) > 1 else 0+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def fit_arima_model(self,+ data: Union[List, np.ndarray, pd.Series],+ order: Tuple[int, int, int] = (1, 0, 1),+ seasonal_order: Optional[Tuple[int, int, int, int]] = None) -> Dict[str, Any]:+ """Fit ARIMA model to time series data."""+ data = self._validate_returns(data, "data")+ self._check_data_length(data, min_length=max(20, sum(order) * 3))++ try:+ from statsmodels.tsa.arima.model import ARIMA++ # Fit ARIMA model+ model = ARIMA(data, order=order, seasonal_order=seasonal_order)+ fitted_model = model.fit()++ # Model diagnostics+ residuals = fitted_model.resid+ fitted_values = fitted_model.fittedvalues++ # Information criteria+ aic = fitted_model.aic+ bic = fitted_model.bic++ # Ljung-Box test for residual autocorrelation+ from statsmodels.stats.diagnostic import acorr_ljungbox+ ljung_box = acorr_ljungbox(residuals, lags=min(10, len(residuals) // 4), return_df=True)++ return self._create_result_dict(+ value={+ 'parameters': fitted_model.params.to_dict(),+ 'fitted_values': fitted_values.tolist(),+ 'residuals': residuals.tolist()+ },+ method='arima_model',+ parameters={+ 'data': data.tolist() if hasattr(data, 'tolist') else list(data),+ 'order': order,+ 'seasonal_order': seasonal_order+ },+ metadata={+ 'aic': aic,+ 'bic': bic,+ 'log_likelihood': fitted_model.llf,+ 'ljung_box_p_value': ljung_box['lb_pvalue'].iloc[-1],+ 'residuals_autocorrelated': ljung_box['lb_pvalue'].iloc[-1] < 0.05,+ 'model_summary': str(fitted_model.summary())+ }+ )++ except ImportError:+ # Fallback: Simple AR(1) model+ if order[0] == 1 and order[1] == 0 and order[2] == 0:+ return self._fit_simple_ar1(data)+ else:+ raise DataValidationError("statsmodels required for ARIMA modeling", "dependencies")++ def _fit_simple_ar1(self, data: np.ndarray) -> Dict[str, Any]:+ """Fallback AR(1) implementation."""+ y = data[1:]+ x = data[:-1]++ # OLS estimation+ X = np.column_stack([np.ones(len(x)), x])+ coefficients = np.linalg.lstsq(X, y, rcond=None)[0]++ intercept, phi = coefficients+ fitted_values = intercept + phi * data[:-1]+ residuals = y - fitted_values++ return self._create_result_dict(+ value={+ 'parameters': {'const': intercept, 'ar.L1': phi},+ 'fitted_values': np.concatenate([[data[0]], fitted_values]).tolist(),+ 'residuals': np.concatenate([[0], residuals]).tolist()+ },+ method='ar1_model',+ parameters={'data': data.tolist()},+ metadata={+ 'r_squared': 1 - np.var(residuals) / np.var(y),+ 'is_stationary': abs(phi) < 1+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def generate_forecasts(self,+ data: Union[List, np.ndarray, pd.Series],+ horizon: int = 5,+ method: str = 'simple_exponential',+ train_size: float = 0.8) -> Dict[str, Any]:+ """Generate forecasts using various methods."""+ data = self._validate_returns(data, "data")+ self._check_data_length(data, min_length=20)++ horizon = int(self._validate_positive(horizon, "horizon"))+ train_size = self._validate_probability(train_size, "train_size")++ # Split data+ split_point = int(len(data) * train_size)+ train_data = data[:split_point]+ test_data = data[split_point:]++ forecasts = {}++ if method == 'simple_exponential':+ # Simple exponential smoothing+ alpha = 0.3 # Smoothing parameter+ smoothed = [train_data[0]]++ for i in range(1, len(train_data)):+ smoothed.append(alpha * train_data[i] + (1 - alpha) * smoothed[-1])++ # Forecast+ forecast_values = [smoothed[-1]] * horizon++ elif method == 'linear_trend':+ # Linear trend forecasting+ time_index = np.arange(len(train_data))+ X = np.column_stack([np.ones(len(time_index)), time_index])+ coefficients = np.linalg.lstsq(X, train_data, rcond=None)[0]++ intercept, slope = coefficients+ future_time = np.arange(len(train_data), len(train_data) + horizon)+ forecast_values = intercept + slope * future_time++ elif method == 'moving_average':+ # Moving average+ window = min(5, len(train_data) // 4)+ last_values = train_data[-window:]+ forecast_values = [np.mean(last_values)] * horizon++ else:+ raise DataValidationError(f"Unknown forecasting method: {method}", "method")++ # Calculate accuracy metrics if test data available+ if len(test_data) > 0:+ n_compare = min(len(test_data), horizon)+ mae = np.mean(np.abs(test_data[:n_compare] - forecast_values[:n_compare]))+ rmse = np.sqrt(np.mean((test_data[:n_compare] - forecast_values[:n_compare]) ** 2))+ mape = np.mean(np.abs((test_data[:n_compare] - forecast_values[:n_compare]) / test_data[:n_compare])) * 100+ else:+ mae = rmse = mape = None++ return self._create_result_dict(+ value=forecast_values,+ method=f'forecast_{method}',+ parameters={+ 'data': data.tolist() if hasattr(data, 'tolist') else list(data),+ 'horizon': horizon,+ 'method': method,+ 'train_size': train_size+ },+ metadata={+ 'train_data_size': len(train_data),+ 'test_data_size': len(test_data),+ 'mae': mae,+ 'rmse': rmse,+ 'mape': mape,+ 'forecast_horizon': horizon+ }+ )++ # ========================================+ # MACHINE LEARNING METHODS+ # ========================================++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def supervised_learning_analysis(self,+ X: Union[np.ndarray, pd.DataFrame],+ y: Union[np.ndarray, pd.Series],+ problem_type: str = 'regression',+ algorithms: List[str] = ['ridge', 'random_forest']) -> Dict[str, Any]:+ """Comprehensive supervised learning analysis."""+ # Validate inputs+ if isinstance(X, pd.DataFrame):+ X = X.values+ if isinstance(y, pd.Series):+ y = y.values++ X = self._validate_numeric_input(X, "X")+ y = self._validate_numeric_input(y, "y")++ if len(X) != len(y):+ raise DataValidationError(f"Length mismatch: X({len(X)}) vs y({len(y)})", "data")++ if problem_type not in ['regression', 'classification']:+ raise DataValidationError(f"Invalid problem_type: {problem_type}", "problem_type")++ # Split data+ X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=self.random_seed)++ # Scale features+ scaler = StandardScaler()+ X_train_scaled = scaler.fit_transform(X_train)+ X_test_scaled = scaler.transform(X_test)++ results = {}++ for algorithm in algorithms:+ try:+ if problem_type == 'regression':+ model = self._get_regression_model(algorithm)+ else:+ model = self._get_classification_model(algorithm)++ # Train model+ if algorithm in ['svm', 'knn']:+ model.fit(X_train_scaled, y_train)+ y_pred = model.predict(X_test_scaled)+ else:+ model.fit(X_train, y_train)+ y_pred = model.predict(X_test)++ # Calculate metrics+ if problem_type == 'regression':+ mse = mean_squared_error(y_test, y_pred)+ r2 = r2_score(y_test, y_pred)+ results[algorithm] = {+ 'mse': mse,+ 'rmse': np.sqrt(mse),+ 'r2_score': r2,+ 'predictions': y_pred.tolist()+ }+ else:+ from sklearn.metrics import accuracy_score, precision_score, recall_score+ accuracy = accuracy_score(y_test, y_pred)+ precision = precision_score(y_test, y_pred, average='weighted')+ recall = recall_score(y_test, y_pred, average='weighted')++ results[algorithm] = {+ 'accuracy': accuracy,+ 'precision': precision,+ 'recall': recall,+ 'predictions': y_pred.tolist()+ }++ except Exception as e:+ results[algorithm] = {'error': str(e)}++ return self._create_result_dict(+ value=results,+ method=f'supervised_learning_{problem_type}',+ parameters={+ 'X_shape': X.shape,+ 'y_shape': y.shape,+ 'problem_type': problem_type,+ 'algorithms': algorithms+ },+ metadata={+ 'train_size': len(X_train),+ 'test_size': len(X_test),+ 'n_features': X.shape[1],+ 'best_algorithm': max(results.keys(), key=lambda k: results[k].get(+ 'r2_score' if problem_type == 'regression' else 'accuracy', -np.inf)) if results else None+ }+ )++ def _get_regression_model(self, algorithm: str):+ """Get regression model by algorithm name."""+ models = {+ 'ridge': Ridge(alpha=1.0, random_state=self.random_seed),+ 'lasso': Lasso(alpha=1.0, random_state=self.random_seed),+ 'elastic_net': ElasticNet(alpha=1.0, random_state=self.random_seed),+ 'svm': SVR(kernel='rbf'),+ 'knn': KNeighborsRegressor(n_neighbors=5),+ 'decision_tree': DecisionTreeRegressor(random_state=self.random_seed),+ 'random_forest': RandomForestRegressor(n_estimators=100, random_state=self.random_seed)+ }+ return models.get(algorithm, Ridge(random_state=self.random_seed))++ def _get_classification_model(self, algorithm: str):+ """Get classification model by algorithm name."""+ models = {+ 'svm': SVC(kernel='rbf', random_state=self.random_seed),+ 'knn': KNeighborsClassifier(n_neighbors=5),+ 'decision_tree': DecisionTreeClassifier(random_state=self.random_seed),+ 'random_forest': RandomForestClassifier(n_estimators=100, random_state=self.random_seed)+ }+ return models.get(algorithm, RandomForestClassifier(random_state=self.random_seed))++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def unsupervised_learning_analysis(self,+ X: Union[np.ndarray, pd.DataFrame],+ methods: List[str] = ['pca', 'kmeans']) -> Dict[str, Any]:+ """Unsupervised learning analysis including PCA and clustering."""+ if isinstance(X, pd.DataFrame):+ X = X.values++ X = self._validate_numeric_input(X, "X")++ # Scale data+ scaler = StandardScaler()+ X_scaled = scaler.fit_transform(X)++ results = {}++ for method in methods:+ try:+ if method == 'pca':+ # Principal Component Analysis+ pca = PCA()+ X_pca = pca.fit_transform(X_scaled)++ # Calculate cumulative explained variance+ cumvar = np.cumsum(pca.explained_variance_ratio_)+ n_components_95 = np.argmax(cumvar >= 0.95) + 1++ results['pca'] = {+ 'explained_variance_ratio': pca.explained_variance_ratio_.tolist(),+ 'cumulative_variance': cumvar.tolist(),+ 'components_for_95_variance': n_components_95,+ 'principal_components': X_pca.tolist()+ }++ elif method == 'kmeans':+ # K-means clustering+ inertias = []+ silhouette_scores = []+ k_range = range(2, min(11, len(X) // 2))++ for k in k_range:+ kmeans = KMeans(n_clusters=k, random_state=self.random_seed)+ cluster_labels = kmeans.fit_predict(X_scaled)+ inertias.append(kmeans.inertia_)++ # Silhouette score+ from sklearn.metrics import silhouette_score+ sil_score = silhouette_score(X_scaled, cluster_labels)+ silhouette_scores.append(sil_score)++ # Find optimal k+ optimal_k = k_range[np.argmax(silhouette_scores)]++ # Final clustering with optimal k+ final_kmeans = KMeans(n_clusters=optimal_k, random_state=self.random_seed)+ final_labels = final_kmeans.fit_predict(X_scaled)++ results['kmeans'] = {+ 'optimal_k': optimal_k,+ 'cluster_labels': final_labels.tolist(),+ 'cluster_centers': final_kmeans.cluster_centers_.tolist(),+ 'inertia_by_k': list(zip(k_range, inertias)),+ 'silhouette_by_k': list(zip(k_range, silhouette_scores))+ }++ elif method == 'hierarchical':+ # Hierarchical clustering+ hierarchical = AgglomerativeClustering(n_clusters=3)+ cluster_labels = hierarchical.fit_predict(X_scaled)++ results['hierarchical'] = {+ 'cluster_labels': cluster_labels.tolist(),+ 'n_clusters': 3+ }++ except Exception as e:+ results[method] = {'error': str(e)}++ return self._create_result_dict(+ value=results,+ method='unsupervised_learning',+ parameters={+ 'X_shape': X.shape,+ 'methods': methods+ },+ metadata={+ 'n_samples': X.shape[0],+ 'n_features': X.shape[1],+ 'data_scaled': True+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def evaluate_model_performance(self,+ X: Union[np.ndarray, pd.DataFrame],+ y: Union[np.ndarray, pd.Series],+ model_type: str = 'random_forest',+ cv_folds: int = 5) -> Dict[str, Any]:+ """Comprehensive model evaluation with cross-validation."""+ if isinstance(X, pd.DataFrame):+ X = X.values+ if isinstance(y, pd.Series):+ y = y.values++ # Determine problem type+ problem_type = 'classification' if len(np.unique(y)) < 10 else 'regression'++ # Get model+ if problem_type == 'regression':+ model = self._get_regression_model(model_type)+ scoring = 'r2'+ else:+ model = self._get_classification_model(model_type)+ scoring = 'accuracy'++ # Cross-validation+ cv_scores = cross_val_score(model, X, y, cv=cv_folds, scoring=scoring)++ # Learning curves (simplified)+ train_sizes = np.linspace(0.1, 1.0, 5)+ train_scores = []+ val_scores = []++ for train_size in train_sizes:+ n_samples = int(len(X) * train_size)+ X_subset = X[:n_samples]+ y_subset = y[:n_samples]++ # Train model+ model.fit(X_subset, y_subset)++ # Training score+ train_pred = model.predict(X_subset)+ if problem_type == 'regression':+ train_score = r2_score(y_subset, train_pred)+ else:+ from sklearn.metrics import accuracy_score+ train_score = accuracy_score(y_subset, train_pred)++ train_scores.append(train_score)++ # Validation score (using remaining data)+ if n_samples < len(X):+ X_val = X[n_samples:]+ y_val = y[n_samples:]+ val_pred = model.predict(X_val)++ if problem_type == 'regression':+ val_score = r2_score(y_val, val_pred)+ else:+ val_score = accuracy_score(y_val, val_pred)+ else:+ val_score = train_score++ val_scores.append(val_score)++ # Overfitting detection+ final_train_score = train_scores[-1]+ final_val_score = val_scores[-1]+ overfitting_score = final_train_score - final_val_score+ is_overfitting = overfitting_score > 0.1++ return self._create_result_dict(+ value={+ 'cv_scores': cv_scores.tolist(),+ 'train_scores': train_scores,+ 'val_scores': val_scores+ },+ method='model_evaluation',+ parameters={+ 'model_type': model_type,+ 'cv_folds': cv_folds,+ 'problem_type': problem_type+ },+ metadata={+ 'mean_cv_score': np.mean(cv_scores),+ 'std_cv_score': np.std(cv_scores),+ 'overfitting_score': overfitting_score,+ 'is_overfitting': is_overfitting,+ 'final_train_score': final_train_score,+ 'final_val_score': final_val_score+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def feature_engineering_analysis(self,+ data: Union[pd.DataFrame, np.ndarray],+ target_column: Optional[str] = None,+ text_columns: Optional[List[str]] = None) -> Dict[str, Any]:+ """Feature engineering including selection and text processing."""+ if isinstance(data, np.ndarray):+ data = pd.DataFrame(data)++ results = {}++ # Feature selection (if target provided)+ if target_column and target_column in data.columns:+ from sklearn.feature_selection import SelectKBest, f_regression, mutual_info_regression++ X = data.drop(columns=[target_column]).select_dtypes(include=[np.number])+ y = data[target_column]++ # Select top features+ selector = SelectKBest(score_func=f_regression, k=min(10, X.shape[1]))+ X_selected = selector.fit_transform(X, y)++ selected_features = X.columns[selector.get_support()].tolist()+ feature_scores = selector.scores_.tolist()++ results['feature_selection'] = {+ 'selected_features': selected_features,+ 'feature_scores': feature_scores,+ 'n_features_selected': len(selected_features)+ }++ # Text processing (basic)+ if text_columns:+ text_stats = {}+ for col in text_columns:+ if col in data.columns:+ text_data = data[col].astype(str)+ text_stats[col] = {+ 'avg_length': text_data.str.len().mean(),+ 'total_unique': text_data.nunique(),+ 'most_common': text_data.value_counts().head().to_dict()+ }++ results['text_analysis'] = text_stats++ # Missing value analysis+ missing_stats = {+ 'missing_by_column': data.isnull().sum().to_dict(),+ 'total_missing': data.isnull().sum().sum(),+ 'missing_percentage': (data.isnull().sum() / len(data) * 100).to_dict()+ }++ results['missing_value_analysis'] = missing_stats++ # Correlation analysis for numeric features+ numeric_data = data.select_dtypes(include=[np.number])+ if not numeric_data.empty:+ correlation_matrix = numeric_data.corr()++ # High correlation pairs+ high_corr_pairs = []+ for i in range(len(correlation_matrix.columns)):+ for j in range(i + 1, len(correlation_matrix.columns)):+ corr_val = correlation_matrix.iloc[i, j]+ if abs(corr_val) > 0.8:+ high_corr_pairs.append({+ 'feature1': correlation_matrix.columns[i],+ 'feature2': correlation_matrix.columns[j],+ 'correlation': corr_val+ })++ results['correlation_analysis'] = {+ 'correlation_matrix': correlation_matrix.to_dict(),+ 'high_correlation_pairs': high_corr_pairs+ }++ return self._create_result_dict(+ value=results,+ method='feature_engineering',+ parameters={+ 'data_shape': data.shape,+ 'target_column': target_column,+ 'text_columns': text_columns+ },+ metadata={+ 'n_numeric_features': len(data.select_dtypes(include=[np.number]).columns),+ 'n_categorical_features': len(data.select_dtypes(include=['object']).columns),+ 'data_quality_score': max(0, 100 - (missing_stats['total_missing'] / data.size * 100))+ }+ )++ # ========================================+ # SAMPLING METHODS+ # ========================================++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def analyze_sampling_techniques(self,+ population: Union[List, np.ndarray, pd.DataFrame],+ sample_size: int,+ sampling_methods: List[str] = ['simple', 'stratified', 'systematic']) -> Dict[+ str, Any]:+ """Demonstrate various sampling techniques."""+ if isinstance(population, pd.DataFrame):+ population_data = population+ else:+ population = self._validate_numeric_input(population, "population")+ population_data = pd.DataFrame({'value': population})++ sample_size = int(self._validate_positive(sample_size, "sample_size"))++ if sample_size >= len(population_data):+ raise DataValidationError("Sample size must be less than population size", "sample_size")++ results = {}++ for method in sampling_methods:+ try:+ if method == 'simple':+ # Simple random sampling+ sample_indices = np.random.choice(len(population_data), size=sample_size, replace=False)+ sample = population_data.iloc[sample_indices]++ elif method == 'stratified':+ # Stratified sampling (using first column for stratification)+ if len(population_data.columns) > 1:+ strata_col = population_data.columns[1]+ else:+ # Create artificial strata based on quantiles+ strata_col = 'artificial_strata'+ population_data[strata_col] = pd.qcut(population_data.iloc[:, 0], q=3,+ labels=['low', 'medium', 'high'])++ sample_list = []+ strata_counts = population_data[strata_col].value_counts()++ for stratum in strata_counts.index:+ stratum_size = len(population_data[population_data[strata_col] == stratum])+ stratum_sample_size = max(1, int(sample_size * stratum_size / len(population_data)))++ stratum_data = population_data[population_data[strata_col] == stratum]+ if len(stratum_data) >= stratum_sample_size:+ stratum_sample = stratum_data.sample(n=stratum_sample_size, random_state=self.random_seed)+ sample_list.append(stratum_sample)++ sample = pd.concat(sample_list) if sample_list else population_data.sample(n=sample_size,+ random_state=self.random_seed)++ elif method == 'systematic':+ # Systematic sampling+ k = len(population_data) // sample_size+ start = np.random.randint(0, k)+ indices = [start + i * k for i in range(sample_size) if start + i * k < len(population_data)]+ sample = population_data.iloc[indices]++ elif method == 'cluster':+ # Cluster sampling (simplified)+ n_clusters = max(2, sample_size // 5)+ cluster_size = len(population_data) // n_clusters++ # Create clusters+ clusters = [population_data.iloc[i:i + cluster_size] for i in+ range(0, len(population_data), cluster_size)]++ # Randomly select clusters+ n_select_clusters = max(1, sample_size // cluster_size)+ selected_clusters = np.random.choice(len(clusters), size=min(n_select_clusters, len(clusters)),+ replace=False)++ sample_list = [clusters[i] for i in selected_clusters]+ sample = pd.concat(sample_list)[:sample_size]++ else:+ continue++ # Calculate sample statistics+ if len(sample) > 0:+ numeric_cols = sample.select_dtypes(include=[np.number]).columns+ if len(numeric_cols) > 0:+ sample_mean = sample[numeric_cols].mean().to_dict()+ sample_std = sample[numeric_cols].std().to_dict()++ # Compare with population+ pop_mean = population_data[numeric_cols].mean().to_dict()+ pop_std = population_data[numeric_cols].std().to_dict()++ results[method] = {+ 'sample_size': len(sample),+ 'sample_mean': sample_mean,+ 'sample_std': sample_std,+ 'population_mean': pop_mean,+ 'population_std': pop_std,+ 'bias': {col: sample_mean[col] - pop_mean[col] for col in sample_mean.keys()}+ }+ else:+ results[method] = {'sample_size': len(sample), 'note': 'No numeric columns for statistics'}++ except Exception as e:+ results[method] = {'error': str(e)}++ return self._create_result_dict(+ value=results,+ method='sampling_techniques',+ parameters={+ 'population_size': len(population_data),+ 'sample_size': sample_size,+ 'sampling_methods': sampling_methods+ },+ metadata={+ 'population_shape': population_data.shape,+ 'sampling_fraction': sample_size / len(population_data)+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def demonstrate_central_limit_theorem(self,+ population_dist: str = 'exponential',+ population_params: Dict[str, float] = None,+ sample_sizes: List[int] = [5, 10, 30, 100],+ n_samples: int = 1000) -> Dict[str, Any]:+ """Demonstrate Central Limit Theorem with various distributions."""+ if population_params is None:+ population_params = {'scale': 1.0}++ n_samples = int(self._validate_positive(n_samples, "n_samples"))++ # Generate population+ if population_dist == 'exponential':+ population = np.random.exponential(scale=population_params.get('scale', 1.0), size=10000)+ elif population_dist == 'uniform':+ low = population_params.get('low', 0)+ high = population_params.get('high', 1)+ population = np.random.uniform(low=low, high=high, size=10000)+ elif population_dist == 'binomial':+ n = population_params.get('n', 10)+ p = population_params.get('p', 0.5)+ population = np.random.binomial(n=n, p=p, size=10000)+ else:+ # Default to normal+ population = np.random.normal(loc=population_params.get('loc', 0),+ scale=population_params.get('scale', 1), size=10000)++ population_mean = np.mean(population)+ population_std = np.std(population)++ results = {}++ for sample_size in sample_sizes:+ sample_means = []++ for _ in range(n_samples):+ sample = np.random.choice(population, size=sample_size, replace=True)+ sample_means.append(np.mean(sample))++ sample_means = np.array(sample_means)++ # Test normality of sample means+ _, shapiro_p = stats.shapiro(sample_means) if len(sample_means) <= 5000 else (None, None)++ # Theoretical vs empirical+ theoretical_mean = population_mean+ theoretical_std = population_std / np.sqrt(sample_size)++ empirical_mean = np.mean(sample_means)+ empirical_std = np.std(sample_means)++ results[f'n_{sample_size}'] = {+ 'sample_means': sample_means.tolist(),+ 'empirical_mean': empirical_mean,+ 'empirical_std': empirical_std,+ 'theoretical_mean': theoretical_mean,+ 'theoretical_std': theoretical_std,+ 'mean_bias': empirical_mean - theoretical_mean,+ 'std_bias': empirical_std - theoretical_std,+ 'shapiro_p_value': shapiro_p,+ 'appears_normal': shapiro_p > 0.05 if shapiro_p is not None else None+ }++ return self._create_result_dict(+ value=results,+ method='central_limit_theorem',+ parameters={+ 'population_dist': population_dist,+ 'population_params': population_params,+ 'sample_sizes': sample_sizes,+ 'n_samples': n_samples+ },+ metadata={+ 'population_mean': population_mean,+ 'population_std': population_std,+ 'population_size': len(population),+ 'clt_convergence': {str(n): results[f'n_{n}']['appears_normal'] for n in sample_sizes if+ f'n_{n}' in results}+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def advanced_resampling_analysis(self,+ data: Union[List, np.ndarray, pd.Series],+ statistic_func: Callable = np.mean,+ methods: List[str] = ['bootstrap', 'jackknife', 'permutation'],+ n_resamples: int = 1000) -> Dict[str, Any]:+ """Advanced resampling methods for statistical inference."""+ data = self._validate_returns(data, "data")+ self._check_data_length(data, min_length=5)++ n_resamples = int(self._validate_positive(n_resamples, "n_resamples"))++ if not callable(statistic_func):+ raise DataValidationError("statistic_func must be callable", "statistic_func")++ # Original statistic+ original_stat = statistic_func(data)++ results = {}++ for method in methods:+ try:+ if method == 'bootstrap':+ # Bootstrap resampling+ bootstrap_stats = []+ for _ in range(n_resamples):+ bootstrap_sample = np.random.choice(data, size=len(data), replace=True)+ bootstrap_stats.append(statistic_func(bootstrap_sample))++ bootstrap_stats = np.array(bootstrap_stats)++ # Confidence interval+ ci_lower = np.percentile(bootstrap_stats, 2.5)+ ci_upper = np.percentile(bootstrap_stats, 97.5)++ results['bootstrap'] = {+ 'resampled_statistics': bootstrap_stats.tolist(),+ 'mean': np.mean(bootstrap_stats),+ 'std': np.std(bootstrap_stats),+ 'bias': np.mean(bootstrap_stats) - original_stat,+ 'confidence_interval': [ci_lower, ci_upper]+ }++ elif method == 'jackknife':+ # Jackknife resampling+ n = len(data)+ jackknife_stats = []++ for i in range(n):+ jackknife_sample = np.concatenate([data[:i], data[i + 1:]])+ jackknife_stats.append(statistic_func(jackknife_sample))++ jackknife_stats = np.array(jackknife_stats)++ # Bias correction+ jackknife_mean = np.mean(jackknife_stats)+ bias = (n - 1) * (jackknife_mean - original_stat)+ bias_corrected = original_stat - bias++ # Variance estimate+ jackknife_var = (n - 1) / n * np.sum((jackknife_stats - jackknife_mean) ** 2)++ results['jackknife'] = {+ 'resampled_statistics': jackknife_stats.tolist(),+ 'bias': bias,+ 'bias_corrected_estimate': bias_corrected,+ 'variance_estimate': jackknife_var,+ 'std_error': np.sqrt(jackknife_var)+ }++ elif method == 'permutation':+ # Permutation test (for hypothesis testing)+ # Test if mean differs from zero+ permutation_stats = []++ for _ in range(n_resamples):+ # Random sign flips+ signs = np.random.choice([-1, 1], size=len(data))+ permuted_data = data * signs+ permutation_stats.append(statistic_func(permuted_data))++ permutation_stats = np.array(permutation_stats)++ # P-value (two-tailed test)+ p_value = np.mean(np.abs(permutation_stats) >= np.abs(original_stat))++ results['permutation'] = {+ 'resampled_statistics': permutation_stats.tolist(),+ 'p_value': p_value,+ 'significant': p_value < 0.05+ }++ except Exception as e:+ results[method] = {'error': str(e)}++ return self._create_result_dict(+ value=results,+ method='advanced_resampling',+ parameters={+ 'data': data.tolist() if hasattr(data, 'tolist') else list(data),+ 'methods': methods,+ 'n_resamples': n_resamples+ },+ metadata={+ 'original_statistic': original_stat,+ 'data_size': len(data),+ 'statistic_name': getattr(statistic_func, '__name__', 'custom_function')+ }+ )++ @validate_inputs+ @timing_decorator+ @handle_calculation_error+ def calculate_sampling_error_analysis(self,+ population_mean: float,+ population_std: float,+ sample_sizes: List[int] = [10, 30, 50, 100, 500],+ confidence_level: float = 0.95,+ n_simulations: int = 1000) -> Dict[str, Any]:+ """Analyze sampling error and determine optimal sample sizes."""+ population_mean = self._validate_numeric_input(population_mean, "population_mean")+ population_std = self._validate_positive(population_std, "population_std")+ confidence_level = self._validate_probability(confidence_level, "confidence_level")+ n_simulations = int(self._validate_positive(n_simulations, "n_simulations"))++ alpha = 1 - confidence_level+ z_critical = stats.norm.ppf(1 - alpha / 2)++ results = {}++ for sample_size in sample_sizes:+ # Theoretical calculations+ standard_error = population_std / np.sqrt(sample_size)+ margin_of_error = z_critical * standard_error++ # Simulation+ sample_means = []+ for _ in range(n_simulations):+ sample = np.random.normal(population_mean, population_std, size=sample_size)+ sample_means.append(np.mean(sample))++ sample_means = np.array(sample_means)++ # Calculate coverage probability+ ci_lower = sample_means - margin_of_error+ ci_upper = sample_means + margin_of_error+ coverage = np.mean((ci_lower <= population_mean) & (population_mean <= ci_upper))++ # Mean squared error+ mse = np.mean((sample_means - population_mean) ** 2)++ results[f'n_{sample_size}'] = {+ 'sample_size': sample_size,+ 'theoretical_se': standard_error,+ 'empirical_se': np.std(sample_means),+ 'theoretical_moe': margin_of_error,+ 'empirical_moe': z_critical * np.std(sample_means),+ 'coverage_probability': coverage,+ 'mean_squared_error': mse,+ 'relative_error': standard_error / population_mean if population_mean != 0 else np.inf+ }++ # Sample size recommendation+ target_moe = 0.1 * population_std # 10% of population std as target+ recommended_n = int(np.ceil((z_critical * population_std / target_moe) ** 2))++ return self._create_result_dict(+ value=results,+ method='sampling_error_analysis',+ parameters={+ 'population_mean': population_mean,+ 'population_std': population_std,+ 'sample_sizes': sample_sizes,+ 'confidence_level': confidence_level,+ 'n_simulations': n_simulations+ },+ metadata={+ 'recommended_sample_size': recommended_n,+ 'target_margin_of_error': target_moe,+ 'z_critical': z_critical,+ 'coverage_target': confidence_level+ }+ )++ # ========================================+ # MAIN CALCULATION DISPATCHER+ # ========================================++ def calculate(self, calculation_type: str, **kwargs) -> Dict[str, Any]:+ """Main calculation dispatcher for all advanced methods."""+ methods = {+ # Time Series+ 'trend_analysis': self.analyze_trend,+ 'stationarity_test': self.test_stationarity,+ 'arima_model': self.fit_arima_model,+ 'forecasting': self.generate_forecasts,++ # Machine Learning+ 'supervised_learning': self.supervised_learning_analysis,+ 'unsupervised_learning': self.unsupervised_learning_analysis,+ 'model_evaluation': self.evaluate_model_performance,+ 'feature_engineering': self.feature_engineering_analysis,++ # Sampling Methods+ 'sampling_techniques': self.analyze_sampling_techniques,+ 'central_limit_theorem': self.demonstrate_central_limit_theorem,+ 'resampling_methods': self.advanced_resampling_analysis,+ 'sampling_error_analysis': self.calculate_sampling_error_analysis+ }++ if calculation_type not in methods:+ raise DataValidationError(f"Unknown calculation type: {calculation_type}", "calculation_type")++ return methods[calculation_type](**kwargs)+++# ========================================+# UTILITY FUNCTIONS FOR QUICK ACCESS+# ========================================++# Time Series Utilities+def detect_trend(data: Union[List, np.ndarray], trend_type: str = 'linear') -> Dict[str, float]:+ """Quick trend detection."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.analyze_trend(data, trend_type)+ return result['value']+++def test_stationarity_quick(data: Union[List, np.ndarray], test: str = 'adf') -> bool:+ """Quick stationarity test."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.test_stationarity(data, test)+ return result['value']['is_stationary']+++def forecast_series(data: Union[List, np.ndarray], horizon: int = 5, method: str = 'simple_exponential') -> List[float]:+ """Quick forecasting."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.generate_forecasts(data, horizon, method)+ return result['value']+++# Machine Learning Utilities+def quick_ml_comparison(X: np.ndarray, y: np.ndarray, problem_type: str = 'regression') -> str:+ """Compare ML algorithms and return best performer."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.supervised_learning_analysis(X, y, problem_type)+ return result['metadata']['best_algorithm']+++def detect_overfitting(X: np.ndarray, y: np.ndarray, model_type: str = 'random_forest') -> bool:+ """Quick overfitting detection."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.evaluate_model_performance(X, y, model_type)+ return result['metadata']['is_overfitting']+++def optimal_clusters(X: np.ndarray) -> int:+ """Find optimal number of clusters."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.unsupervised_learning_analysis(X, ['kmeans'])+ return result['value']['kmeans']['optimal_k']+++# Sampling Utilities+def compare_sampling_methods(population: np.ndarray, sample_size: int) -> Dict[str, float]:+ """Compare different sampling methods."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.analyze_sampling_techniques(population, sample_size)+ return {method: data.get('bias', {}).get('value', 0) for method, data in result['value'].items() if+ isinstance(data, dict)}+++def required_sample_size(population_std: float, margin_of_error: float, confidence: float = 0.95) -> int:+ """Calculate required sample size."""+ z_critical = stats.norm.ppf(1 - (1 - confidence) / 2)+ return int(np.ceil((z_critical * population_std / margin_of_error) ** 2))+++def clt_convergence_check(dist_type: str = 'exponential', sample_sizes: List[int] = [5, 30, 100]) -> Dict[int, bool]:+ """Check CLT convergence for different sample sizes."""+ analyzer = AdvancedQuantAnalyzer()+ result = analyzer.demonstrate_central_limit_theorem(dist_type, sample_sizes=sample_sizes)+ return result['metadata']['clt_convergence']\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/rate_calculations.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/rate_calculations.pynew file mode 100644index 000000000..f4529734e--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/rate_calculations.py@@ -0,0 +1,29 @@++Quantitative Rate Calculations Module+=================================++Interest rate and yield calculations++===== DATA SOURCES REQUIRED =====+INPUT:+ - High-frequency market data and price series+ - Order book data and market microstructure+ - Alternative data sources and sentiment indicators+ - Economic data and market fundamentals+ - Historical factor returns and premiums++OUTPUT:+ - Quantitative trading signals and strategies+ - Factor model implementations and analysis+ - Risk models and portfolio construction methods+ - Backtest results and performance attribution+ - Alpha generation and research insights++PARAMETERS:+ - factor_model: Factor model type (default: 'fama_french_5')+ - lookback_period: Historical lookback window (default: 252 days)+ - rebalance_frequency: Strategy rebalancing frequency (default: 'monthly')+ - universe_size: Investment universe size (default: 1000)+ - risk_model: Risk model for portfolio construction (default: 'barra')++diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/tree b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/treenew file mode 100644index 000000000..5299f0142--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/quant/tree@@ -0,0 +1,136 @@+analytics/+└── quant/+ ├── __init__.py+ ├── core/+ │ ├── __init__.py+ │ ├── base_calculator.py # Base class for all calculators+ │ ├── data_validator.py # Input validation & data quality+ │ └── exceptions.py # Custom exception classes+ │+ ├── returns_analysis/+ │ ├── __init__.py+ │ ├── rate_calculations.py # Interest rates, discount rates+ │ ├── return_measures.py # All return calculation methods+ │ ├── performance_metrics.py # Sharpe, Sortino, etc.+ │ └── risk_metrics.py # VaR, CVaR, volatility measures+ │+ ├── time_value_money/+ │ ├── __init__.py+ │ ├── present_value.py # PV calculations for all instruments+ │ ├── future_value.py # FV calculations+ │ ├── cash_flow_analysis.py # NPV, IRR, cash flow additivity+ │ ├── bond_valuation.py # Fixed income valuation+ │ ├── equity_valuation.py # Equity instrument valuation+ │ └── forward_rates.py # Implied forward rates+ │+ ├── statistical_analysis/+ │ ├── __init__.py+ │ ├── descriptive_stats.py # Central tendency, dispersion+ │ ├── distribution_analysis.py # Skewness, kurtosis, normality+ │ ├── correlation_analysis.py # Correlation, covariance matrices+ │ └── outlier_detection.py # Statistical outlier methods+ │+ ├── probability_simulation/+ │ ├── __init__.py+ │ ├── probability_trees.py # Probability trees, conditional expectations+ │ ├── bayes_theorem.py # Bayesian updates+ │ ├── monte_carlo.py # Monte Carlo simulation engine+ │ ├── bootstrap_methods.py # Bootstrap & jackknife resampling+ │ └── distribution_models.py # Normal, lognormal, custom distributions+ │+ ├── portfolio_mathematics/+ │ ├── __init__.py+ │ ├── portfolio_returns.py # Portfolio return calculations+ │ ├── portfolio_risk.py # Portfolio risk metrics+ │ ├── efficient_frontier.py # Modern portfolio theory+ │ ├── safety_first.py # Roy's safety-first criterion+ │ └── optimization.py # Portfolio optimization algorithms+ │+ ├── hypothesis_testing/+ │ ├── __init__.py+ │ ├── parametric_tests.py # t-tests, z-tests, F-tests+ │ ├── nonparametric_tests.py # Chi-square, Mann-Whitney, etc.+ │ ├── independence_tests.py # Contingency tables, correlation tests+ │ ├── power_analysis.py # Statistical power calculations+ │ └── multiple_testing.py # Bonferroni, FDR corrections+ │+ ├── regression_analysis/+ │ ├── __init__.py+ │ ├── simple_regression.py # Simple linear regression (Level I)+ │ ├── multiple_regression.py # Multiple regression (Level II)+ │ ├── logistic_regression.py # Logistic regression (Level II)+ │ ├── model_diagnostics.py # Residual analysis, assumption testing+ │ ├── model_selection.py # Variable selection, model comparison+ │ ├── influence_analysis.py # Outlier detection, leverage+ │ └── heteroskedasticity.py # Heteroskedasticity tests & corrections+ │+ ├── time_series_analysis/+ │ ├── __init__.py+ │ ├── trend_analysis.py # Linear & log-linear trends+ │ ├── stationarity.py # Stationarity tests, unit root tests+ │ ├── autoregressive_models.py # AR, MA, ARMA models+ │ ├── mean_reversion.py # Mean reversion analysis+ │ ├── forecasting.py # In-sample vs out-of-sample forecasting+ │ ├── seasonality.py # Seasonal decomposition & modeling+ │ ├── arch_garch.py # ARCH/GARCH volatility modeling+ │ ├── cointegration.py # Cointegration analysis+ │ └── model_evaluation.py # RMSE, forecast accuracy metrics+ │+ ├── machine_learning/+ │ ├── __init__.py+ │ ├── supervised_learning/+ │ │ ├── __init__.py+ │ │ ├── penalized_regression.py # Ridge, Lasso, Elastic Net+ │ │ ├── support_vector_machine.py+ │ │ ├── k_nearest_neighbor.py+ │ │ ├── decision_trees.py # CART, Random Forest+ │ │ └── ensemble_methods.py # Bagging, Boosting+ │ ├── unsupervised_learning/+ │ │ ├── __init__.py+ │ │ ├── pca_analysis.py # Principal Component Analysis+ │ │ ├── clustering_methods.py # K-means, Hierarchical clustering+ │ │ └── dimensionality_reduction.py+ │ ├── model_evaluation/+ │ │ ├── __init__.py+ │ │ ├── cross_validation.py+ │ │ ├── overfitting_detection.py+ │ │ └── performance_metrics.py+ │ └── feature_engineering/+ │ ├── __init__.py+ │ ├── text_processing.py # NLP for financial text+ │ ├── feature_selection.py+ │ └── data_preprocessing.py+ │+ ├── big_data_projects/+ │ ├── __init__.py+ │ ├── data_pipeline/+ │ │ ├── __init__.py+ │ │ ├── data_extraction.py # Data source connectors+ │ │ ├── data_cleaning.py # Data wrangling & preparation+ │ │ ├── data_exploration.py # EDA tools+ │ │ └── data_validation.py # Data quality checks+ │ ├── text_analytics/+ │ │ ├── __init__.py+ │ │ ├── text_preprocessing.py # Text cleaning, tokenization+ │ │ ├── feature_extraction.py # TF-IDF, word embeddings+ │ │ └── sentiment_analysis.py # Financial sentiment analysis+ │ └── model_deployment/+ │ ├── __init__.py+ │ ├── model_training.py # Training pipeline+ │ ├── model_validation.py # Model evaluation+ │ └── production_pipeline.py # Production deployment+ │+ ├── sampling_methods/+ │ ├── __init__.py+ │ ├── sampling_techniques.py # Random, stratified, cluster sampling+ │ ├── central_limit_theorem.py # CLT demonstrations+ │ ├── resampling_methods.py # Bootstrap, jackknife+ │ └── sampling_error_analysis.py # Sampling error calculations+ │+ └── utils/+ ├── __init__.py+ ├── data_connectors.py # Interface for different data sources+ ├── visualization.py # Plotting utilities+ ├── export_functions.py # Export to various formats+ ├── configuration.py # Configuration management+ └── performance_monitoring.py # Performance tracking\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/riskfoliolib_wrapper.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/riskfoliolib_wrapper.pynew file mode 100644index 000000000..2042f752f--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/riskfoliolib_wrapper.py@@ -0,0 +1,63 @@+"""+Risk Portfolio Analytics Module+===============================++Advanced portfolio risk management and optimization using specialized risk libraries.+Provides comprehensive risk analysis including Value-at-Risk, Conditional VaR,+stress testing, scenario analysis, and sophisticated risk budgeting strategies+for institutional portfolio management.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Pandas DataFrame with portfolio asset returns/price data+ - Risk factor data for multi-factor models+ - Market indices for benchmarking and beta calculation+ - Volatility surface and correlation data+ - Portfolio holdings and constraint parameters++OUTPUT:+ - Portfolio risk metrics (VaR, CVaR, EVaR, drawdowns)+ - Risk budgeting and allocation recommendations+ - Stress test results under various market scenarios+ - Factor exposure analysis and risk attribution+ - Correlation analysis and clustering results+ - Risk-adjusted performance metrics++PARAMETERS:+ - confidence_level: VaR/CVaR confidence level (default: 0.95)+ - time_horizon: Risk measurement horizon in days (default: 1)+ - lookback_window: Historical data window (default: 252)+ - rebalance_frequency: Portfolio rebalancing frequency (default: 21)+ - max_weight: Maximum single asset weight (default: 0.3)+ - risk_budget: Risk budget allocation strategy (default: 'equal')+ - stress_scenarios: Custom stress test scenarios (default: None)+ - factor_model: Factor model for risk decomposition (default: 'CAPM')+"""++# This is a wrapper module for risk portfolio analytics libraries+# Implement risk-specific functionality here++class RiskPortfolioAnalytics:+ """+ Risk-focused portfolio analytics engine for comprehensive risk management+ """++ def __init__(self):+ self.risk_metrics = {}+ self.scenario_results = {}++ def calculate_var(self, returns, confidence_level=0.95):+ """Calculate Value-at-Risk"""+ pass++ def calculate_cvar(self, returns, confidence_level=0.95):+ """Calculate Conditional Value-at-Risk"""+ pass++ def stress_test(self, portfolio, scenarios):+ """Perform stress testing on portfolio"""+ pass++ def risk_budgeting(self, assets, risk_budget):+ """Allocate risk budget across assets"""+ pass\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/skfolio_wrapper.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/skfolio_wrapper.pynew file mode 100644index 000000000..1db22f34b--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/skfolio_wrapper.py@@ -0,0 +1,1099 @@+"""+Advanced Portfolio Analytics Module+===================================++Sophisticated portfolio optimization and analytics using skfolio library.+Provides state-of-the-art portfolio management techniques including hierarchical+risk parity, mean-variance optimization with advanced risk measures, factor-based+modeling, copula simulation, and comprehensive performance attribution.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Pandas DataFrame with asset price/return data (datetime index)+ - Factor model data (optional, for enhanced analysis)+ - Market benchmarks and indices+ - Portfolio constraints and optimization parameters++OUTPUT:+ - Optimal portfolio weights using multiple optimization methods+ - Risk decomposition and performance attribution+ - Efficient frontier and optimization landscapes+ - Hyperparameter tuning and model validation results+ - Walk-forward backtest with performance metrics+ - Stress testing and scenario analysis outcomes++PARAMETERS:+ - optimization_method: Portfolio optimization algorithm (default: 'mean_risk')+ - objective_function: Optimization objective (default: 'maximize_ratio')+ - risk_measure: Risk metric for optimization (default: 'variance')+ - covariance_estimator: Covariance estimation method (default: 'empirical')+ - train_test_split_ratio: Data split ratio (default: 0.7)+ - lookback_window: Trading days for analysis (default: 252)+ - rebalance_frequency: Rebalancing frequency in days (default: 21)+ - confidence_level: Statistical confidence level (default: 0.95)+ - l1_coef: L1 regularization strength (default: 0.0)+ - l2_coef: L2 regularization strength (default: 0.0)+"""++import pandas as pd+import numpy as np+import matplotlib.pyplot as plt+import seaborn as sns+import plotly.graph_objects as go+import plotly.express as px+from plotly.subplots import make_subplots+import warnings+from typing import Dict, List, Optional, Union, Tuple, Any+from dataclasses import dataclass, field+from datetime import datetime, timedelta+import json++# skfolio imports+from sklearn.model_selection import train_test_split, GridSearchCV, RandomizedSearchCV, KFold+from sklearn.pipeline import Pipeline+from scipy.stats import loguniform++from skfolio import RatioMeasure, RiskMeasure+from skfolio.datasets import load_sp500_dataset, load_factors_dataset+from skfolio.distribution import VineCopula+from skfolio.model_selection import CombinatorialPurgedCV, WalkForward, cross_val_predict+from skfolio.moments import (+ DenoiseCovariance, DetoneCovariance, EWMu, GerberCovariance,+ ShrunkMu, LedoitWolf+)+from skfolio.optimization import (+ MeanRisk, HierarchicalRiskParity, NestedClustersOptimization,+ ObjectiveFunction, RiskBudgeting, MaximumDiversification,+ EqualWeighted, InverseVolatility, Random+)+from skfolio.pre_selection import SelectKExtremes+from skfolio.preprocessing import prices_to_returns+from skfolio.prior import (+ BlackLitterman, EmpiricalPrior, EntropyPooling, FactorModel,+ OpinionPooling, SyntheticData+)+from skfolio.uncertainty_set import BootstrapMuUncertaintySet++warnings.filterwarnings('ignore')++@dataclass+class PortfolioConfig:+ """Configuration class for portfolio optimization parameters"""++ # Basic Settings+ optimization_method: str = "mean_risk" # mean_risk, risk_parity, hrp, max_div, equal_weight+ objective_function: str = "minimize_risk" # minimize_risk, maximize_return, maximize_ratio, maximize_utility+ risk_measure: str = "variance" # variance, cvar, semi_variance, max_drawdown, etc.++ # Data Settings+ train_test_split_ratio: float = 0.7+ lookback_window: int = 252 # trading days+ rebalance_frequency: int = 21 # days++ # Risk Management+ min_weights: Optional[Dict[str, float]] = None+ max_weights: Union[float, Dict[str, float]] = 1.0+ max_weight_single_asset: float = 0.3+ transaction_costs: Optional[Dict[str, float]] = None++ # Advanced Parameters+ l1_coef: float = 0.0 # L1 regularization+ l2_coef: float = 0.0 # L2 regularization+ risk_aversion: float = 1.0+ confidence_level: float = 0.95++ # Covariance Estimation+ covariance_estimator: str = "empirical" # empirical, ledoit_wolf, gerber, denoise+ mu_estimator: str = "empirical" # empirical, shrunk, ew++ # Cross-validation+ cv_method: str = "kfold" # kfold, walk_forward, combinatorial_purged+ cv_folds: int = 5++ # Black-Litterman+ views: Optional[List[str]] = None+ tau: float = 0.025++ # Factor Model+ use_factor_model: bool = False+ factor_views: Optional[List[str]] = None++ # Clustering (for HRP)+ clustering_method: str = "hierarchical"+ linkage_method: str = "ward"++ # Uncertainty Sets+ use_uncertainty_set: bool = False+ bootstrap_samples: int = 1000++ # Constraints+ group_constraints: Optional[List[str]] = None+ turnover_constraint: Optional[float] = None+ tracking_error_constraint: Optional[float] = None++ def __post_init__(self):+ """Validate configuration parameters"""+ if not 0 < self.train_test_split_ratio < 1:+ raise ValueError("train_test_split_ratio must be between 0 and 1")+ if self.confidence_level <= 0 or self.confidence_level >= 1:+ raise ValueError("confidence_level must be between 0 and 1")+++class PortfolioAnalyticsEngine:+ """+ Advanced Portfolio Analytics Engine using skfolio++ Features:+ - Multiple optimization methods+ - Risk management and analysis+ - Stress testing and scenario analysis+ - Performance attribution+ - Interactive visualizations+ - Backtesting capabilities+ """++ def __init__(self, config: PortfolioConfig = None):+ self.config = config or PortfolioConfig()+ self.prices = None+ self.returns = None+ self.factors = None+ self.factor_returns = None+ self.model = None+ self.portfolio = None+ self.backtest_results = {}+ self.optimization_history = []++ def load_data(self,+ prices: pd.DataFrame,+ factors: pd.DataFrame = None,+ start_date: str = None,+ end_date: str = None) -> None:+ """+ Load price and factor data++ Parameters:+ -----------+ prices : pd.DataFrame+ Asset prices with datetime index and asset columns+ factors : pd.DataFrame, optional+ Factor data with datetime index+ start_date, end_date : str, optional+ Date range for analysis+ """+ # Filter by date range if provided+ if start_date or end_date:+ if start_date:+ prices = prices[prices.index >= start_date]+ if factors is not None:+ factors = factors[factors.index >= start_date]+ if end_date:+ prices = prices[prices.index <= end_date]+ if factors is not None:+ factors = factors[factors.index <= end_date]++ self.prices = prices+ self.returns = prices_to_returns(prices)++ if factors is not None:+ self.factors = factors+ self.factor_returns = prices_to_returns(factors) if 'price' in str(factors.columns).lower() else factors++ print(f"Data loaded: {len(self.prices)} periods, {len(self.prices.columns)} assets")+ if factors is not None:+ print(f"Factor data: {len(self.factors.columns)} factors")++ def _get_estimators(self) -> Tuple[Any, Any]:+ """Get covariance and mu estimators based on config"""++ # Covariance estimators+ covariance_estimators = {+ "empirical": None,+ "ledoit_wolf": LedoitWolf(),+ "gerber": GerberCovariance(),+ "denoise": DenoiseCovariance(),+ "detone": DetoneCovariance()+ }++ # Mu estimators+ mu_estimators = {+ "empirical": None,+ "shrunk": ShrunkMu(),+ "ew": EWMu(alpha=0.2)+ }++ cov_est = covariance_estimators.get(self.config.covariance_estimator)+ mu_est = mu_estimators.get(self.config.mu_estimator)++ return cov_est, mu_est++ def _build_prior_estimator(self) -> Any:+ """Build prior estimator based on configuration"""+ cov_est, mu_est = self._get_estimators()++ # Base empirical prior+ empirical_prior = EmpiricalPrior(+ mu_estimator=mu_est,+ covariance_estimator=cov_est+ )++ # Black-Litterman+ if self.config.views:+ return BlackLitterman(+ views=self.config.views,+ tau=self.config.tau,+ prior_estimator=empirical_prior+ )++ # Factor Model+ if self.config.use_factor_model and self.factor_returns is not None:+ factor_prior = BlackLitterman(+ views=self.config.factor_views,+ tau=self.config.tau+ ) if self.config.factor_views else empirical_prior++ return FactorModel(+ factor_prior_estimator=factor_prior+ )++ return empirical_prior++ def _build_model(self) -> Any:+ """Build optimization model based on configuration"""++ # Get objective function+ obj_functions = {+ "minimize_risk": ObjectiveFunction.MINIMIZE_RISK,+ "maximize_return": ObjectiveFunction.MAXIMIZE_RETURN,+ "maximize_ratio": ObjectiveFunction.MAXIMIZE_RATIO,+ "maximize_utility": ObjectiveFunction.MAXIMIZE_UTILITY+ }++ # Get risk measure+ risk_measures = {+ "variance": RiskMeasure.VARIANCE,+ "semi_variance": RiskMeasure.SEMI_VARIANCE,+ "cvar": RiskMeasure.CVAR,+ "evar": RiskMeasure.EVAR,+ "max_drawdown": RiskMeasure.MAX_DRAWDOWN,+ "cdar": RiskMeasure.CDAR,+ "ulcer_index": RiskMeasure.ULCER_INDEX+ }++ prior_estimator = self._build_prior_estimator()+ uncertainty_set = BootstrapMuUncertaintySet() if self.config.use_uncertainty_set else None++ # Build model based on optimization method+ if self.config.optimization_method == "mean_risk":+ model = MeanRisk(+ objective_function=obj_functions[self.config.objective_function],+ risk_measure=risk_measures[self.config.risk_measure],+ prior_estimator=prior_estimator,+ mu_uncertainty_set_estimator=uncertainty_set,+ min_weights=self.config.min_weights,+ max_weights=self.config.max_weights,+ transaction_costs=self.config.transaction_costs,+ l1_coef=self.config.l1_coef,+ l2_coef=self.config.l2_coef,+ risk_aversion=self.config.risk_aversion+ )++ elif self.config.optimization_method == "risk_parity":+ model = RiskBudgeting(+ risk_measure=risk_measures[self.config.risk_measure],+ prior_estimator=prior_estimator,+ min_weights=self.config.min_weights,+ max_weights=self.config.max_weights+ )++ elif self.config.optimization_method == "hrp":+ model = HierarchicalRiskParity(+ risk_measure=risk_measures[self.config.risk_measure],+ prior_estimator=prior_estimator,+ linkage_method=self.config.linkage_method+ )++ elif self.config.optimization_method == "max_div":+ model = MaximumDiversification(+ prior_estimator=prior_estimator,+ min_weights=self.config.min_weights,+ max_weights=self.config.max_weights+ )++ elif self.config.optimization_method == "equal_weight":+ model = EqualWeighted()++ elif self.config.optimization_method == "inverse_vol":+ model = InverseVolatility(prior_estimator=prior_estimator)++ else:+ raise ValueError(f"Unknown optimization method: {self.config.optimization_method}")++ return model++ def optimize_portfolio(self,+ train_size: float = None,+ verbose: bool = True) -> Dict[str, Any]:+ """+ Optimize portfolio using configured parameters++ Returns:+ --------+ Dict with optimization results+ """+ if self.returns is None:+ raise ValueError("No data loaded. Call load_data() first.")++ train_size = train_size or self.config.train_test_split_ratio++ # Split data+ if self.factor_returns is not None:+ X_train, X_test, factors_train, factors_test = train_test_split(+ self.returns, self.factor_returns,+ test_size=1-train_size, shuffle=False+ )+ else:+ X_train, X_test = train_test_split(+ self.returns, test_size=1-train_size, shuffle=False+ )+ factors_train = factors_test = None++ # Build and fit model+ self.model = self._build_model()++ if factors_train is not None:+ self.model.fit(X_train, factors_train)+ else:+ self.model.fit(X_train)++ # Generate portfolio+ self.portfolio = self.model.predict(X_test)++ # Store results+ results = {+ 'weights': dict(zip(self.returns.columns, self.model.weights_)),+ 'train_period': (X_train.index[0], X_train.index[-1]),+ 'test_period': (X_test.index[0], X_test.index[-1]),+ 'model_type': self.config.optimization_method,+ 'objective': self.config.objective_function,+ 'risk_measure': self.config.risk_measure+ }++ # Performance metrics+ if hasattr(self.portfolio, 'sharpe_ratio'):+ results.update({+ 'sharpe_ratio': self.portfolio.sharpe_ratio,+ 'sortino_ratio': getattr(self.portfolio, 'sortino_ratio', None),+ 'calmar_ratio': getattr(self.portfolio, 'calmar_ratio', None),+ 'max_drawdown': getattr(self.portfolio, 'max_drawdown', None),+ 'volatility': getattr(self.portfolio, 'annualized_volatility', None),+ 'return': getattr(self.portfolio, 'annualized_mean', None)+ })++ self.optimization_history.append(results)++ if verbose:+ print(f"\nPortfolio Optimization Complete:")+ print(f"Method: {self.config.optimization_method}")+ print(f"Objective: {self.config.objective_function}")+ print(f"Risk Measure: {self.config.risk_measure}")+ print(f"Training Period: {results['train_period'][0]} to {results['train_period'][1]}")+ print(f"Test Period: {results['test_period'][0]} to {results['test_period'][1]}")+ if 'sharpe_ratio' in results:+ print(f"Sharpe Ratio: {results['sharpe_ratio']:.4f}")++ return results++ def hyperparameter_tuning(self,+ param_grid: Dict = None,+ cv_method: str = None,+ scoring = None,+ n_jobs: int = -1) -> Dict[str, Any]:+ """+ Perform hyperparameter tuning using grid search or random search++ Parameters:+ -----------+ param_grid : dict+ Parameter grid for tuning+ cv_method : str+ Cross-validation method+ scoring : str+ Scoring metric+ n_jobs : int+ Number of parallel jobs+ """+ if param_grid is None:+ param_grid = {+ 'l1_coef': [0.0, 0.001, 0.01, 0.1],+ 'l2_coef': [0.0, 0.001, 0.01, 0.1],+ 'risk_aversion': [0.5, 1.0, 2.0, 5.0]+ }++ # Cross-validation strategy+ cv_method = cv_method or self.config.cv_method+ if cv_method == "walk_forward":+ cv = WalkForward(train_size=self.config.lookback_window,+ test_size=self.config.rebalance_frequency)+ elif cv_method == "combinatorial_purged":+ cv = CombinatorialPurgedCV(n_folds=self.config.cv_folds)+ else:+ cv = KFold(n_splits=self.config.cv_folds, shuffle=False)++ # Grid search+ grid_search = GridSearchCV(+ estimator=self._build_model(),+ param_grid=param_grid,+ cv=cv,+ n_jobs=n_jobs,+ verbose=1+ )++ if self.factor_returns is not None:+ grid_search.fit(self.returns, self.factor_returns)+ else:+ grid_search.fit(self.returns)++ # Update model with best parameters+ self.model = grid_search.best_estimator_++ return {+ 'best_params': grid_search.best_params_,+ 'best_score': grid_search.best_score_,+ 'cv_results': grid_search.cv_results_+ }++ def backtest_strategy(self,+ rebalance_freq: int = None,+ window_size: int = None,+ start_date: str = None,+ end_date: str = None) -> pd.DataFrame:+ """+ Backtest the portfolio strategy using walk-forward analysis++ Parameters:+ -----------+ rebalance_freq : int+ Rebalancing frequency in days+ window_size : int+ Rolling window size for optimization+ start_date, end_date : str+ Backtest date range++ Returns:+ --------+ DataFrame with backtest results+ """+ rebalance_freq = rebalance_freq or self.config.rebalance_frequency+ window_size = window_size or self.config.lookback_window++ # Filter data for backtest period+ returns_data = self.returns.copy()+ if start_date:+ returns_data = returns_data[returns_data.index >= start_date]+ if end_date:+ returns_data = returns_data[returns_data.index <= end_date]++ # Walk-forward backtest+ backtest_dates = []+ portfolio_returns = []+ weights_history = []++ for i in range(window_size, len(returns_data), rebalance_freq):+ # Training window+ train_data = returns_data.iloc[i-window_size:i]++ # Build and fit model+ model = self._build_model()++ try:+ if self.factor_returns is not None:+ factor_data = self.factor_returns.iloc[i-window_size:i]+ model.fit(train_data, factor_data)+ else:+ model.fit(train_data)++ # Get weights+ weights = pd.Series(model.weights_, index=train_data.columns)+ weights_history.append(weights)++ # Calculate forward returns+ end_idx = min(i + rebalance_freq, len(returns_data))+ forward_returns = returns_data.iloc[i:end_idx]++ # Portfolio returns+ ptf_returns = (forward_returns * weights).sum(axis=1)+ portfolio_returns.extend(ptf_returns.values)+ backtest_dates.extend(forward_returns.index)++ except Exception as e:+ print(f"Error at period {i}: {e}")+ continue++ # Create backtest results DataFrame+ backtest_df = pd.DataFrame({+ 'date': backtest_dates,+ 'portfolio_return': portfolio_returns+ }).set_index('date')++ # Calculate performance metrics+ backtest_df['cumulative_return'] = (1 + backtest_df['portfolio_return']).cumprod()+ backtest_df['drawdown'] = (backtest_df['cumulative_return'] /+ backtest_df['cumulative_return'].expanding().max() - 1)++ self.backtest_results = {+ 'returns': backtest_df,+ 'weights_history': weights_history,+ 'metrics': self._calculate_performance_metrics(backtest_df['portfolio_return'])+ }++ return backtest_df++ def stress_test(self,+ scenarios: Dict[str, Dict] = None,+ n_simulations: int = 10000) -> Dict[str, Any]:+ """+ Perform stress testing using various scenarios++ Parameters:+ -----------+ scenarios : dict+ Stress test scenarios+ n_simulations : int+ Number of Monte Carlo simulations+ """+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ stress_results = {}++ # Default stress scenarios+ if scenarios is None:+ scenarios = {+ 'market_crash': {'market_shock': -0.20},+ 'high_volatility': {'volatility_mult': 2.0},+ 'recession': {'gdp_shock': -0.05},+ 'inflation_spike': {'inflation_shock': 0.10}+ }++ # Monte Carlo stress testing+ if hasattr(self.model, 'prior_estimator_'):+ prior = self.model.prior_estimator_++ # Generate synthetic returns using vine copula+ vine = VineCopula(log_transform=True, n_jobs=-1)+ vine.fit(self.returns)++ for scenario_name, scenario_params in scenarios.items():+ try:+ # Generate stressed scenarios+ conditioning = scenario_params if 'market_shock' in scenario_params else None+ synthetic_returns = vine.sample(n_samples=n_simulations,+ conditioning=conditioning)++ # Calculate portfolio performance under stress+ stressed_portfolio = self.model.predict(synthetic_returns)++ stress_results[scenario_name] = {+ 'mean_return': synthetic_returns.mean().mean(),+ 'volatility': synthetic_returns.std().mean(),+ 'portfolio_var': np.percentile(stressed_portfolio.returns, 5),+ 'portfolio_cvar': stressed_portfolio.returns[+ stressed_portfolio.returns <= np.percentile(stressed_portfolio.returns, 5)+ ].mean()+ }++ except Exception as e:+ print(f"Error in scenario {scenario_name}: {e}")+ continue++ return stress_results++ def _calculate_performance_metrics(self, returns: pd.Series) -> Dict[str, float]:+ """Calculate comprehensive performance metrics"""+ returns_annual = returns.mean() * 252+ volatility_annual = returns.std() * np.sqrt(252)++ # Drawdown calculation+ cumulative = (1 + returns).cumprod()+ rolling_max = cumulative.expanding().max()+ drawdown = (cumulative - rolling_max) / rolling_max++ metrics = {+ 'annual_return': returns_annual,+ 'annual_volatility': volatility_annual,+ 'sharpe_ratio': returns_annual / volatility_annual if volatility_annual > 0 else 0,+ 'max_drawdown': drawdown.min(),+ 'calmar_ratio': returns_annual / abs(drawdown.min()) if drawdown.min() < 0 else 0,+ 'sortino_ratio': returns_annual / (returns[returns < 0].std() * np.sqrt(252)) if len(returns[returns < 0]) > 0 else 0,+ 'skewness': returns.skew(),+ 'kurtosis': returns.kurt(),+ 'var_95': np.percentile(returns, 5),+ 'cvar_95': returns[returns <= np.percentile(returns, 5)].mean(),+ 'win_rate': (returns > 0).sum() / len(returns)+ }++ return metrics++ def plot_weights(self, top_n: int = 15, figsize: Tuple[int, int] = (12, 8)) -> go.Figure:+ """Plot portfolio weights"""+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ weights = pd.Series(self.model.weights_, index=self.returns.columns)+ weights = weights.sort_values(key=abs, ascending=False)[:top_n]++ # Create plotly bar chart+ fig = go.Figure(data=[+ go.Bar(+ x=weights.index,+ y=weights.values,+ marker_color=['red' if x < 0 else 'blue' for x in weights.values],+ text=[f'{x:.2%}' for x in weights.values],+ textposition='outside'+ )+ ])++ fig.update_layout(+ title=f'Portfolio Weights - {self.config.optimization_method.title()}',+ xaxis_title='Assets',+ yaxis_title='Weight',+ yaxis_tickformat='.1%',+ height=500+ )++ return fig++ def plot_efficient_frontier(self, n_portfolios: int = 100) -> go.Figure:+ """Plot efficient frontier"""+ if self.returns is None:+ raise ValueError("No data loaded. Call load_data() first.")++ # Generate efficient frontier+ returns_range = np.linspace(self.returns.mean().min() * 252,+ self.returns.mean().max() * 252,+ n_portfolios)++ risks = []+ returns_list = []++ for target_return in returns_range:+ try:+ model = MeanRisk(+ objective_function=ObjectiveFunction.MINIMIZE_RISK,+ risk_measure=RiskMeasure.VARIANCE,+ min_return=target_return/252+ )+ model.fit(self.returns)++ portfolio_risk = np.sqrt(model.weights_ @ self.returns.cov() @ model.weights_) * np.sqrt(252)+ risks.append(portfolio_risk)+ returns_list.append(target_return)++ except:+ continue++ # Plot+ fig = go.Figure()++ fig.add_trace(go.Scatter(+ x=risks, y=returns_list,+ mode='lines+markers',+ name='Efficient Frontier',+ line=dict(color='blue', width=2)+ ))++ # Add current portfolio point if available+ if self.model is not None:+ current_return = self.portfolio.annualized_mean if hasattr(self.portfolio, 'annualized_mean') else 0+ current_risk = self.portfolio.annualized_volatility if hasattr(self.portfolio, 'annualized_volatility') else 0++ fig.add_trace(go.Scatter(+ x=[current_risk], y=[current_return],+ mode='markers',+ name='Current Portfolio',+ marker=dict(color='red', size=10, symbol='star')+ ))++ fig.update_layout(+ title='Efficient Frontier',+ xaxis_title='Risk (Volatility)',+ yaxis_title='Expected Return',+ xaxis_tickformat='.1%',+ yaxis_tickformat='.1%'+ )++ return fig++ def plot_backtest_results(self) -> go.Figure:+ """Plot backtest results"""+ if not self.backtest_results:+ raise ValueError("No backtest results. Run backtest_strategy() first.")++ df = self.backtest_results['returns']++ # Create subplots+ fig = make_subplots(+ rows=2, cols=1,+ subplot_titles=['Cumulative Returns', 'Drawdown'],+ vertical_spacing=0.1+ )++ # Cumulative returns+ fig.add_trace(+ go.Scatter(x=df.index, y=df['cumulative_return'],+ name='Portfolio', line=dict(color='blue')),+ row=1, col=1+ )++ # Drawdown+ fig.add_trace(+ go.Scatter(x=df.index, y=df['drawdown'],+ name='Drawdown', fill='tonexty',+ line=dict(color='red')),+ row=2, col=1+ )++ fig.update_layout(height=600, title='Backtest Results')+ fig.update_yaxes(tickformat='.1%', row=1, col=1)+ fig.update_yaxes(tickformat='.1%', row=2, col=1)++ return fig++ def generate_report(self) -> Dict[str, Any]:+ """Generate comprehensive portfolio analytics report"""+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ report = {+ 'timestamp': datetime.now().isoformat(),+ 'configuration': {+ 'optimization_method': self.config.optimization_method,+ 'objective_function': self.config.objective_function,+ 'risk_measure': self.config.risk_measure,+ 'covariance_estimator': self.config.covariance_estimator,+ 'mu_estimator': self.config.mu_estimator+ },+ 'portfolio_weights': dict(zip(self.returns.columns, self.model.weights_)),+ 'top_10_positions': dict(+ pd.Series(self.model.weights_, index=self.returns.columns)+ .sort_values(key=abs, ascending=False)[:10]+ ),+ 'performance_metrics': {},+ 'risk_analysis': {},+ 'optimization_history': self.optimization_history+ }++ # Performance metrics+ if hasattr(self.portfolio, 'sharpe_ratio'):+ report['performance_metrics'] = {+ 'sharpe_ratio': self.portfolio.sharpe_ratio,+ 'sortino_ratio': getattr(self.portfolio, 'sortino_ratio', None),+ 'calmar_ratio': getattr(self.portfolio, 'calmar_ratio', None),+ 'max_drawdown': getattr(self.portfolio, 'max_drawdown', None),+ 'annual_volatility': getattr(self.portfolio, 'annualized_volatility', None),+ 'annual_return': getattr(self.portfolio, 'annualized_mean', None)+ }++ # Risk analysis+ portfolio_returns = self.portfolio.returns if hasattr(self.portfolio, 'returns') else None+ if portfolio_returns is not None:+ report['risk_analysis'] = {+ 'var_95': np.percentile(portfolio_returns, 5),+ 'cvar_95': portfolio_returns[portfolio_returns <= np.percentile(portfolio_returns, 5)].mean(),+ 'skewness': portfolio_returns.skew() if hasattr(portfolio_returns, 'skew') else None,+ 'kurtosis': portfolio_returns.kurtosis() if hasattr(portfolio_returns, 'kurtosis') else None,+ 'volatility': portfolio_returns.std() * np.sqrt(252)+ }++ # Backtest results+ if self.backtest_results:+ report['backtest_results'] = self.backtest_results['metrics']++ return report++ def save_report(self, filename: str = None) -> str:+ """Save portfolio analytics report to JSON file"""+ if filename is None:+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ filename = f"portfolio_report_{timestamp}.json"++ report = self.generate_report()++ # Convert numpy types to native Python types for JSON serialization+ def convert_numpy(obj):+ if isinstance(obj, np.ndarray):+ return obj.tolist()+ elif isinstance(obj, np.integer):+ return int(obj)+ elif isinstance(obj, np.floating):+ return float(obj)+ elif isinstance(obj, pd.Series):+ return obj.to_dict()+ elif isinstance(obj, pd.DataFrame):+ return obj.to_dict('records')+ return obj++ # Recursively convert numpy types+ def recursive_convert(obj):+ if isinstance(obj, dict):+ return {k: recursive_convert(v) for k, v in obj.items()}+ elif isinstance(obj, list):+ return [recursive_convert(v) for v in obj]+ else:+ return convert_numpy(obj)++ report_serializable = recursive_convert(report)++ with open(filename, 'w') as f:+ json.dump(report_serializable, f, indent=2, default=str)++ print(f"Report saved to: {filename}")+ return filename++ def export_weights_to_csv(self, filename: str = None) -> str:+ """Export portfolio weights to CSV file"""+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ if filename is None:+ timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")+ filename = f"portfolio_weights_{timestamp}.csv"++ weights_df = pd.DataFrame({+ 'Asset': self.returns.columns,+ 'Weight': self.model.weights_,+ 'Weight_Percent': self.model.weights_ * 100+ }).sort_values('Weight', key=abs, ascending=False)++ weights_df.to_csv(filename, index=False)+ print(f"Weights exported to: {filename}")+ return filename++ def compare_strategies(self,+ strategies: List[Dict[str, Any]],+ metric: str = 'sharpe_ratio') -> pd.DataFrame:+ """+ Compare multiple optimization strategies++ Parameters:+ -----------+ strategies : List[Dict]+ List of strategy configurations+ metric : str+ Comparison metric++ Returns:+ --------+ DataFrame with strategy comparison results+ """+ results = []++ for i, strategy_config in enumerate(strategies):+ try:+ # Create temporary config+ temp_config = PortfolioConfig(**strategy_config)+ temp_engine = PortfolioAnalyticsEngine(temp_config)+ temp_engine.load_data(self.prices, self.factors)++ # Optimize+ result = temp_engine.optimize_portfolio(verbose=False)+ result['strategy_id'] = f"Strategy_{i+1}"+ result['config'] = strategy_config+ results.append(result)++ except Exception as e:+ print(f"Error in strategy {i+1}: {e}")+ continue++ # Create comparison DataFrame+ comparison_df = pd.DataFrame(results)++ if metric in comparison_df.columns:+ comparison_df = comparison_df.sort_values(metric, ascending=False)++ return comparison_df++ def risk_attribution(self) -> Dict[str, pd.DataFrame]:+ """+ Perform risk attribution analysis++ Returns:+ --------+ Dictionary with risk attribution results+ """+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ weights = pd.Series(self.model.weights_, index=self.returns.columns)+ cov_matrix = self.returns.cov() * 252 # Annualized++ # Portfolio variance+ portfolio_var = weights.T @ cov_matrix @ weights+ portfolio_vol = np.sqrt(portfolio_var)++ # Marginal contribution to risk+ marginal_contrib = (cov_matrix @ weights) / portfolio_vol++ # Component contribution to risk+ component_contrib = weights * marginal_contrib++ # Percentage contribution to risk+ pct_contrib = component_contrib / portfolio_vol * 100++ # Risk attribution DataFrame+ risk_attrib_df = pd.DataFrame({+ 'Asset': self.returns.columns,+ 'Weight': weights.values,+ 'Weight_Pct': weights.values * 100,+ 'Marginal_Risk': marginal_contrib.values,+ 'Component_Risk': component_contrib.values,+ 'Risk_Contribution_Pct': pct_contrib.values,+ 'Individual_Vol': np.sqrt(np.diag(cov_matrix)) * 100+ }).sort_values('Risk_Contribution_Pct', key=abs, ascending=False)++ # Sector attribution if available+ sector_attrib = None+ if hasattr(self, 'sector_mapping') and self.sector_mapping:+ risk_attrib_df['Sector'] = risk_attrib_df['Asset'].map(self.sector_mapping)+ sector_attrib = risk_attrib_df.groupby('Sector').agg({+ 'Weight_Pct': 'sum',+ 'Risk_Contribution_Pct': 'sum',+ 'Component_Risk': 'sum'+ }).sort_values('Risk_Contribution_Pct', ascending=False)++ return {+ 'asset_attribution': risk_attrib_df,+ 'sector_attribution': sector_attrib,+ 'portfolio_volatility': portfolio_vol,+ 'portfolio_variance': portfolio_var+ }++ def scenario_analysis(self, scenarios: Dict[str, pd.DataFrame]) -> Dict[str, Any]:+ """+ Perform scenario analysis with custom return scenarios++ Parameters:+ -----------+ scenarios : Dict[str, pd.DataFrame]+ Dictionary of scenario names and their return DataFrames++ Returns:+ --------+ Dictionary with scenario analysis results+ """+ if self.model is None:+ raise ValueError("No model fitted. Run optimize_portfolio() first.")++ scenario_results = {}++ for scenario_name, scenario_returns in scenarios.items():+ try:+ # Ensure scenario returns have same columns as training data+ common_assets = scenario_returns.columns.intersection(self.returns.columns)+ scenario_subset = scenario_returns[common_assets]++ # Get weights for common assets+ weights_subset = pd.Series(self.model.weights_, index=self.returns.columns)[common_assets]+ weights_subset = weights_subset / weights_subset.sum() # Renormalize++ # Calculate portfolio returns under scenario+ portfolio_returns = (scenario_subset * weights_subset).sum(axis=1)++ # Calculate metrics+ scenario_results[scenario_name] = {+ 'total_return': (1 + portfolio_returns).prod() - 1,+ 'annualized_return': portfolio_returns.mean() * 252,+ 'volatility': portfolio_returns.std() * np.sqrt(252),+ 'sharpe_ratio': (portfolio_returns.mean() * 252) / (portfolio_returns.std() * np.sqrt(252)),+ 'max_drawdown': ((1 + portfolio_returns).cumprod() /+ (1 + portfolio_returns).cumprod().expanding().max() - 1).min(),+ 'var_95': np.percentile(portfolio_returns, 5),+ 'cvar_95': portfolio_returns[portfolio_returns <= np.percentile(portfolio_returns, 5)].mean(),+ 'worst_day': portfolio_returns.min(),+ 'best_day': portfolio_returns.max(),+ 'n_periods': len(portfolio_returns)+ }++ except Exception as e:+ print(f"Error in scenario {scenario_name}: {e}")+ scenario_results[scenario_name] = {'error': str(e)}++ return scenario_results++ def set_sector_mapping(self, sector_mapping: Dict[str, str]):+ """Set sector mapping for assets for sector-level analysis"""+ self.sector_mapping = sector_mapping+++# Example Usage and Testing Functions+def create_sample_config() -> PortfolioConfig:+ """Create a sample configuration for testing"""+ return PortfolioConfig(+ optimization_method="mean_risk",+ objective_function="maximize_ratio",+ risk_measure="cvar",+ covariance_estimator="ledoit_wolf",+ mu_estimator="shrunk",+ max_weight_single_asset=0.15,+ l2_coef=0.01,+ cv_method="walk_forward",+ cv_folds=5,+ use_uncertainty_set=True+ )++def demo_portfolio_analytics():+ """Demonstration of the portfolio analytics engine"""++ # Load sample data+ print("Loading sample data...")+ prices = load_sp500_dataset()++ # Create configuration+ config = create_sample_config()++ # Initialize engine+ engine = PortfolioAnalyticsEngine(config)+ engine.load_data(prices)++ # Optimize portfolio+ print("\nOptimizing portfolio...")+ results = engine.optimize_portfolio()++ # Print top 10 weights+ weights = pd.Series(engine.model.weights_, index=engine.returns.columns)+ print("\nTop 10 Positions:")+ print(weights.sort_values(key=abs, ascending=False)[:10].to_string())++ # Hyperparameter tuning+ print("\nPerforming hyperparameter tuning...")+ tuning_results = engine.hyperparameter_tuning()+ print(f"Best parameters: {tuning_results['best_params']}")+ print(f"Best score: {tuning_results['best_score']:.4f}")++ # Backtest+ print("\nRunning backtest...")+ backtest_df = engine.backtest_strategy()+ print(f"Backtest performance metrics:")+ for metric, value in engine.backtest_results['metrics'].items():+ if isinstance(value, (int, float)):+ print(f"{metric}: {value:.4f}")++ # Risk attribution+ print("\nRisk attribution analysis...")+ risk_attrib = engine.risk_attribution()+ print("Top 5 risk contributors:")+ print(risk_attrib['asset_attribution'][['Asset', 'Weight_Pct', 'Risk_Contribution_Pct']].head().to_string(index=False))++ # Generate and save report+ print("\nGenerating comprehensive report...")+ report_file = engine.save_report()+ weights_file = engine.export_weights_to_csv()++ print(f"\nDemo completed successfully!")+ print(f"Files generated: {report_file}, {weights_file}")++ return engine++if __name__ == "__main__":+ # Run demonstration+ engine = demo_portfolio_analytics()\ No newline at end of filediff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/technical_indicators.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/technical_indicators.pynew file mode 100644index 000000000..183d61eb1--- /dev/null+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/technical_indicators.py@@ -0,0 +1,497 @@+# -*- coding: utf-8 -*-+"""+Technical Analysis Indicators Module+===================================++Comprehensive technical analysis indicators for financial market analysis.+Provides 10 essential technical indicators including moving averages, momentum+oscillators, volatility measures, and trend analysis tools with robust error+handling and flexible input support for various data formats.++===== DATA SOURCES REQUIRED =====+INPUT:+ - Pandas Series or NumPy array with price data (OHLCV format preferred)+ - Time series data with datetime index (optional but recommended)+ - High, Low, Close prices for OHLC-based indicators+ - Volume data for volume-based indicators (future enhancement)++OUTPUT:+ - Moving averages (SMA, EMA) with configurable periods+ - Momentum oscillators (RSI, Stochastic, Williams %R)+ - Trend indicators (MACD with signal and histogram)+ - Volatility measures (Bollinger Bands, ATR)+ - Strength indicators (ADX, CCI) with directional components++PARAMETERS:+ - period: Lookback period for indicators (default varies by indicator)+ - std_dev: Standard deviation multiplier for bands (default: 2.0)+ - fast/slow: Fast and slow periods for MACD (default: 12, 26)+ - signal: Signal line period for MACD (default: 9)+ - k_period/d_period: Stochastic oscillator periods (default: 14, 3)+ - confidence_level: Statistical confidence for analysis (default: 0.95)+ - min_periods: Minimum data points required (default: period)+"""++import numpy as np+import pandas as pd+from typing import Union, Tuple, Optional+import warnings++# Suppress pandas warnings for cleaner output+warnings.filterwarnings("ignore", category=FutureWarning)+++class TechnicalIndicators:+ """+ A comprehensive collection of technical analysis indicators.++ This class provides static methods for calculating various technical indicators+ used in financial market analysis.+ """++ @staticmethod+ def sma(data: Union[pd.Series, np.ndarray], period: int = 20) -> pd.Series:+ """+ Simple Moving Average (SMA)++ Args:+ data: Price data (typically closing prices)+ period: Number of periods for the moving average++ Returns:+ pd.Series: Simple moving average values+ """+ try:+ if isinstance(data, np.ndarray):+ data = pd.Series(data)++ return data.rolling(window=period, min_periods=period).mean()+ except Exception as e:+ print(f"Error calculating SMA: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def ema(data: Union[pd.Series, np.ndarray], period: int = 20) -> pd.Series:+ """+ Exponential Moving Average (EMA)++ Args:+ data: Price data (typically closing prices)+ period: Number of periods for the exponential moving average++ Returns:+ pd.Series: Exponential moving average values+ """+ try:+ if isinstance(data, np.ndarray):+ data = pd.Series(data)++ return data.ewm(span=period, adjust=False).mean()+ except Exception as e:+ print(f"Error calculating EMA: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def rsi(data: Union[pd.Series, np.ndarray], period: int = 14) -> pd.Series:+ """+ Relative Strength Index (RSI)++ Args:+ data: Price data (typically closing prices)+ period: Number of periods for RSI calculation++ Returns:+ pd.Series: RSI values (0-100)+ """+ try:+ if isinstance(data, np.ndarray):+ data = pd.Series(data)++ delta = data.diff()+ gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()+ loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()++ rs = gain / loss+ rsi = 100 - (100 / (1 + rs))++ return rsi+ except Exception as e:+ print(f"Error calculating RSI: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def macd(data: Union[pd.Series, np.ndarray], fast: int = 12, slow: int = 26, signal: int = 9) -> Tuple[pd.Series, pd.Series, pd.Series]:+ """+ Moving Average Convergence Divergence (MACD)++ Args:+ data: Price data (typically closing prices)+ fast: Fast EMA period+ slow: Slow EMA period+ signal: Signal line EMA period++ Returns:+ Tuple[pd.Series, pd.Series, pd.Series]: (MACD line, Signal line, Histogram)+ """+ try:+ if isinstance(data, np.ndarray):+ data = pd.Series(data)++ ema_fast = data.ewm(span=fast).mean()+ ema_slow = data.ewm(span=slow).mean()++ macd_line = ema_fast - ema_slow+ signal_line = macd_line.ewm(span=signal).mean()+ histogram = macd_line - signal_line++ return macd_line, signal_line, histogram+ except Exception as e:+ print(f"Error calculating MACD: {e}")+ return pd.Series(dtype=float), pd.Series(dtype=float), pd.Series(dtype=float)++ @staticmethod+ def bollinger_bands(data: Union[pd.Series, np.ndarray], period: int = 20, std_dev: float = 2) -> Tuple[pd.Series, pd.Series, pd.Series]:+ """+ Bollinger Bands++ Args:+ data: Price data (typically closing prices)+ period: Number of periods for moving average+ std_dev: Number of standard deviations for bands++ Returns:+ Tuple[pd.Series, pd.Series, pd.Series]: (Upper band, Middle band, Lower band)+ """+ try:+ if isinstance(data, np.ndarray):+ data = pd.Series(data)++ middle_band = data.rolling(window=period).mean()+ std = data.rolling(window=period).std()++ upper_band = middle_band + (std * std_dev)+ lower_band = middle_band - (std * std_dev)++ return upper_band, middle_band, lower_band+ except Exception as e:+ print(f"Error calculating Bollinger Bands: {e}")+ return pd.Series(dtype=float), pd.Series(dtype=float), pd.Series(dtype=float)++ @staticmethod+ def stochastic_oscillator(high: Union[pd.Series, np.ndarray],+ low: Union[pd.Series, np.ndarray],+ close: Union[pd.Series, np.ndarray],+ k_period: int = 14,+ d_period: int = 3) -> Tuple[pd.Series, pd.Series]:+ """+ Stochastic Oscillator++ Args:+ high: High prices+ low: Low prices+ close: Closing prices+ k_period: %K period+ d_period: %D period (smoothing)++ Returns:+ Tuple[pd.Series, pd.Series]: (%K, %D)+ """+ try:+ if isinstance(high, np.ndarray):+ high = pd.Series(high)+ if isinstance(low, np.ndarray):+ low = pd.Series(low)+ if isinstance(close, np.ndarray):+ close = pd.Series(close)++ lowest_low = low.rolling(window=k_period).min()+ highest_high = high.rolling(window=k_period).max()++ k_percent = 100 * ((close - lowest_low) / (highest_high - lowest_low))+ d_percent = k_percent.rolling(window=d_period).mean()++ return k_percent, d_percent+ except Exception as e:+ print(f"Error calculating Stochastic Oscillator: {e}")+ return pd.Series(dtype=float), pd.Series(dtype=float)++ @staticmethod+ def williams_r(high: Union[pd.Series, np.ndarray],+ low: Union[pd.Series, np.ndarray],+ close: Union[pd.Series, np.ndarray],+ period: int = 14) -> pd.Series:+ """+ Williams %R++ Args:+ high: High prices+ low: Low prices+ close: Closing prices+ period: Number of periods++ Returns:+ pd.Series: Williams %R values (-100 to 0)+ """+ try:+ if isinstance(high, np.ndarray):+ high = pd.Series(high)+ if isinstance(low, np.ndarray):+ low = pd.Series(low)+ if isinstance(close, np.ndarray):+ close = pd.Series(close)++ highest_high = high.rolling(window=period).max()+ lowest_low = low.rolling(window=period).min()++ williams_r = -100 * ((highest_high - close) / (highest_high - lowest_low))++ return williams_r+ except Exception as e:+ print(f"Error calculating Williams %R: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def atr(high: Union[pd.Series, np.ndarray],+ low: Union[pd.Series, np.ndarray],+ close: Union[pd.Series, np.ndarray],+ period: int = 14) -> pd.Series:+ """+ Average True Range (ATR)++ Args:+ high: High prices+ low: Low prices+ close: Closing prices+ period: Number of periods++ Returns:+ pd.Series: ATR values+ """+ try:+ if isinstance(high, np.ndarray):+ high = pd.Series(high)+ if isinstance(low, np.ndarray):+ low = pd.Series(low)+ if isinstance(close, np.ndarray):+ close = pd.Series(close)++ tr1 = high - low+ tr2 = abs(high - close.shift())+ tr3 = abs(low - close.shift())++ true_range = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)+ atr = true_range.rolling(window=period).mean()++ return atr+ except Exception as e:+ print(f"Error calculating ATR: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def cci(high: Union[pd.Series, np.ndarray],+ low: Union[pd.Series, np.ndarray],+ close: Union[pd.Series, np.ndarray],+ period: int = 20) -> pd.Series:+ """+ Commodity Channel Index (CCI)++ Args:+ high: High prices+ low: Low prices+ close: Closing prices+ period: Number of periods++ Returns:+ pd.Series: CCI values+ """+ try:+ if isinstance(high, np.ndarray):+ high = pd.Series(high)+ if isinstance(low, np.ndarray):+ low = pd.Series(low)+ if isinstance(close, np.ndarray):+ close = pd.Series(close)++ typical_price = (high + low + close) / 3+ sma_tp = typical_price.rolling(window=period).mean()+ mean_deviation = typical_price.rolling(window=period).apply(+ lambda x: np.mean(np.abs(x - np.mean(x)))+ )++ cci = (typical_price - sma_tp) / (0.015 * mean_deviation)++ return cci+ except Exception as e:+ print(f"Error calculating CCI: {e}")+ return pd.Series(dtype=float)++ @staticmethod+ def adx(high: Union[pd.Series, np.ndarray],+ low: Union[pd.Series, np.ndarray],+ close: Union[pd.Series, np.ndarray],+ period: int = 14) -> Tuple[pd.Series, pd.Series, pd.Series]:+ """+ Average Directional Index (ADX) with +DI and -DI++ Args:+ high: High prices+ low: Low prices+ close: Closing prices+ period: Number of periods++ Returns:+ Tuple[pd.Series, pd.Series, pd.Series]: (ADX, +DI, -DI)+ """+ try:+ if isinstance(high, np.ndarray):+ high = pd.Series(high)+ if isinstance(low, np.ndarray):+ low = pd.Series(low)+ if isinstance(close, np.ndarray):+ close = pd.Series(close)++ # Calculate True Range+ tr1 = high - low+ tr2 = abs(high - close.shift())+ tr3 = abs(low - close.shift())+ tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)++ # Calculate Directional Movements+ up_move = high - high.shift()+ down_move = low.shift() - low++ plus_dm = np.where((up_move > down_move) & (up_move > 0), up_move, 0)+ minus_dm = np.where((down_move > up_move) & (down_move > 0), down_move, 0)++ plus_dm = pd.Series(plus_dm, index=high.index)+ minus_dm = pd.Series(minus_dm, index=high.index)++ # Smooth the values+ atr = tr.ewm(span=period).mean()+ plus_di = 100 * (plus_dm.ewm(span=period).mean() / atr)+ minus_di = 100 * (minus_dm.ewm(span=period).mean() / atr)++ # Calculate ADX+ dx = 100 * abs(plus_di - minus_di) / (plus_di + minus_di)+ adx = dx.ewm(span=period).mean()++ return adx, plus_di, minus_di+ except Exception as e:+ print(f"Error calculating ADX: {e}")+ return pd.Series(dtype=float), pd.Series(dtype=float), pd.Series(dtype=float)+++def calculate_all_indicators(df: pd.DataFrame,+ price_col: str = 'close',+ high_col: str = 'high',+ low_col: str = 'low') -> pd.DataFrame:+ """+ Calculate all technical indicators for a given dataframe.++ Args:+ df: DataFrame with OHLC data+ price_col: Column name for closing prices+ high_col: Column name for high prices+ low_col: Column name for low prices++ Returns:+ pd.DataFrame: Original dataframe with added indicator columns+ """+ try:+ result_df = df.copy()++ # Price-based indicators+ result_df['SMA_20'] = TechnicalIndicators.sma(df[price_col], 20)+ result_df['EMA_20'] = TechnicalIndicators.ema(df[price_col], 20)+ result_df['RSI_14'] = TechnicalIndicators.rsi(df[price_col], 14)++ # MACD+ macd, signal, histogram = TechnicalIndicators.macd(df[price_col])+ result_df['MACD'] = macd+ result_df['MACD_Signal'] = signal+ result_df['MACD_Histogram'] = histogram++ # Bollinger Bands+ bb_upper, bb_middle, bb_lower = TechnicalIndicators.bollinger_bands(df[price_col])+ result_df['BB_Upper'] = bb_upper+ result_df['BB_Middle'] = bb_middle+ result_df['BB_Lower'] = bb_lower++ # OHLC-based indicators+ if high_col in df.columns and low_col in df.columns:+ # Stochastic+ stoch_k, stoch_d = TechnicalIndicators.stochastic_oscillator(+ df[high_col], df[low_col], df[price_col]+ )+ result_df['Stoch_K'] = stoch_k+ result_df['Stoch_D'] = stoch_d++ # Williams %R+ result_df['Williams_R'] = TechnicalIndicators.williams_r(+ df[high_col], df[low_col], df[price_col]+ )++ # ATR+ result_df['ATR'] = TechnicalIndicators.atr(+ df[high_col], df[low_col], df[price_col]+ )++ # CCI+ result_df['CCI'] = TechnicalIndicators.cci(+ df[high_col], df[low_col], df[price_col]+ )++ # ADX+ adx, plus_di, minus_di = TechnicalIndicators.adx(+ df[high_col], df[low_col], df[price_col]+ )+ result_df['ADX'] = adx+ result_df['Plus_DI'] = plus_di+ result_df['Minus_DI'] = minus_di++ print(f"Successfully calculated all technical indicators for {len(result_df)} data points")+ return result_df++ except Exception as e:+ print(f"Error calculating indicators: {e}")+ return df+++# Example usage and testing+if __name__ == "__main__":+ # Create sample data for testing+ np.random.seed(42)+ dates = pd.date_range(start='2023-01-01', end='2024-01-01', freq='D')++ # Generate realistic price data+ base_price = 100+ returns = np.random.normal(0.001, 0.02, len(dates))+ prices = [base_price]++ for ret in returns[1:]:+ prices.append(prices[-1] * (1 + ret))++ # Create OHLC data+ sample_data = pd.DataFrame({+ 'date': dates,+ 'close': prices,+ 'high': [p * (1 + abs(np.random.normal(0, 0.01))) for p in prices],+ 'low': [p * (1 - abs(np.random.normal(0, 0.01))) for p in prices],+ 'volume': np.random.randint(1000, 10000, len(dates))+ })++ # Calculate all indicators+ result = calculate_all_indicators(sample_data)++ print("Technical Indicators Module Test Results:")+ print("=" * 50)+ print(f"Data points: {len(result)}")+ print(f"Indicators calculated: {len([col for col in result.columns if col not in sample_data.columns])}")+ print("\nIndicator columns added:")+ for col in result.columns:+ if col not in sample_data.columns:+ print(f" - {col}")++ print("\nSample of latest 5 indicator values:")+ indicator_cols = [col for col in result.columns if col not in sample_data.columns]+ print(result[indicator_cols].tail().round(2))\ No newline at end of file