Position Sizing

#!/usr/bin/env python3
"""Portfolio-level position sizer and risk dashboard.

Analyzes a portfolio of positions, calculates per-position and total risk,
correlation-adjusted risk, and recommends sizing for the next trade.

Usage:
    python scripts/portfolio_sizer.py          # Uses demo portfolio
    python scripts/portfolio_sizer.py --demo   # Explicitly use demo data

Dependencies:
    None (pure math, no external packages required)

Environment Variables:
    ACCOUNT_SIZE: Total account value in USD (default: 15000, i.e. ~100 SOL)
"""

import math
import os
import sys
from typing import Optional


# ── Configuration ───────────────────────────────────────────────────

ACCOUNT_SIZE = float(os.getenv("ACCOUNT_SIZE", "15000"))

# Portfolio limits
MAX_SINGLE_POSITION_PCT = 0.10   # 10% max single position
MAX_CORRELATED_PCT = 0.25        # 25% max correlated exposure
MAX_TOTAL_EXPOSURE_PCT = 0.70    # 70% max total exposure
DEFAULT_RISK_PCT = 0.02          # 2% risk per trade
DEFAULT_CORRELATION = 0.50       # Assumed correlation within same sector


# ── Data Structures ─────────────────────────────────────────────────

class Position:
    """Represents a single portfolio position.

    Attributes:
        symbol: Token symbol.
        entry_price: Price at entry.
        current_price: Current market price.
        stop_loss: Stop loss price.
        units: Number of units held.
        sector: Sector/category for correlation grouping.
    """

    def __init__(
        self,
        symbol: str,
        entry_price: float,
        current_price: float,
        stop_loss: float,
        units: float,
        sector: str = "general",
    ) -> None:
        self.symbol = symbol
        self.entry_price = entry_price
        self.current_price = current_price
        self.stop_loss = stop_loss
        self.units = units
        self.sector = sector

    @property
    def position_value(self) -> float:
        """Current position value."""
        return self.units * self.current_price

    @property
    def entry_value(self) -> float:
        """Position value at entry."""
        return self.units * self.entry_price

    @property
    def unrealized_pnl(self) -> float:
        """Unrealized profit/loss."""
        return self.units * (self.current_price - self.entry_price)

    @property
    def unrealized_pnl_pct(self) -> float:
        """Unrealized P&L as percentage of entry value."""
        if self.entry_value == 0:
            return 0.0
        return (self.unrealized_pnl / self.entry_value) * 100

    @property
    def risk_per_unit(self) -> float:
        """Dollar risk per unit (distance to stop)."""
        return abs(self.current_price - self.stop_loss)

    @property
    def total_risk(self) -> float:
        """Total dollar risk if stop is hit."""
        return self.units * self.risk_per_unit

    @property
    def risk_reward_from_current(self) -> float:
        """Current risk as fraction of current value."""
        if self.position_value == 0:
            return 0.0
        return self.total_risk / self.position_value


# ── Demo Data ───────────────────────────────────────────────────────

def get_demo_positions() -> list:
    """Return a demo portfolio with 5 example positions.

    Returns:
        List of Position objects representing a sample portfolio.
    """
    return [
        Position(
            symbol="SOL",
            entry_price=145.00,
            current_price=150.00,
            stop_loss=135.00,
            units=20.0,
            sector="l1",
        ),
        Position(
            symbol="JUP",
            entry_price=0.72,
            current_price=0.80,
            stop_loss=0.60,
            units=5000.0,
            sector="defi",
        ),
        Position(
            symbol="BONK",
            entry_price=0.000018,
            current_price=0.000020,
            stop_loss=0.000012,
            units=50_000_000.0,
            sector="meme",
        ),
        Position(
            symbol="WIF",
            entry_price=1.80,
            current_price=1.65,
            stop_loss=1.40,
            units=500.0,
            sector="meme",
        ),
        Position(
            symbol="PYTH",
            entry_price=0.35,
            current_price=0.38,
            stop_loss=0.28,
            units=3000.0,
            sector="defi",
        ),
    ]


# ── Portfolio Analytics ─────────────────────────────────────────────

def calculate_portfolio_metrics(
    positions: list,
    account_size: float,
) -> dict:
    """Calculate portfolio-level risk metrics.

    Args:
        positions: List of Position objects.
        account_size: Total account value in USD.

    Returns:
        Dictionary containing portfolio metrics.
    """
    total_value = sum(p.position_value for p in positions)
    total_risk = sum(p.total_risk for p in positions)
    total_pnl = sum(p.unrealized_pnl for p in positions)
    cash = account_size - total_value

    # Exposure percentages
    exposure_pct = (total_value / account_size) * 100 if account_size > 0 else 0
    risk_pct = (total_risk / account_size) * 100 if account_size > 0 else 0
    cash_pct = (cash / account_size) * 100 if account_size > 0 else 0

    return {
        "total_value": total_value,
        "total_risk": total_risk,
        "total_pnl": total_pnl,
        "cash": cash,
        "exposure_pct": exposure_pct,
        "risk_pct": risk_pct,
        "cash_pct": cash_pct,
        "num_positions": len(positions),
    }


def calculate_sector_exposure(
    positions: list,
    account_size: float,
) -> dict:
    """Calculate exposure by sector for correlation analysis.

    Args:
        positions: List of Position objects.
        account_size: Total account value.

    Returns:
        Dictionary mapping sector to exposure metrics.
    """
    sectors: dict = {}
    for p in positions:
        if p.sector not in sectors:
            sectors[p.sector] = {
                "positions": [],
                "total_value": 0.0,
                "total_risk": 0.0,
            }
        sectors[p.sector]["positions"].append(p.symbol)
        sectors[p.sector]["total_value"] += p.position_value
        sectors[p.sector]["total_risk"] += p.total_risk

    for sector_data in sectors.values():
        sector_data["exposure_pct"] = (sector_data["total_value"] / account_size) * 100
        sector_data["risk_pct"] = (sector_data["total_risk"] / account_size) * 100

    return sectors


def calculate_correlation_adjusted_risk(
    positions: list,
    default_corr: float = DEFAULT_CORRELATION,
) -> float:
    """Calculate portfolio risk adjusted for assumed correlation.

    Uses a simplified model where positions in the same sector have
    a fixed correlation and positions in different sectors are uncorrelated.

    The correlation-adjusted portfolio variance is:
        Var(P) = sum(var_i) + 2 * sum_{i<j, same sector}(corr * std_i * std_j)

    Args:
        positions: List of Position objects.
        default_corr: Assumed correlation between same-sector positions.

    Returns:
        Correlation-adjusted total risk in USD.
    """
    if not positions:
        return 0.0

    # Group by sector
    sectors: dict = {}
    for p in positions:
        if p.sector not in sectors:
            sectors[p.sector] = []
        sectors[p.sector].append(p.total_risk)

    total_variance = 0.0

    for sector_risks in sectors.values():
        n = len(sector_risks)
        # Variance of each position's risk (treat risk as std dev proxy)
        for risk in sector_risks:
            total_variance += risk ** 2

        # Cross-terms for correlated positions
        for i in range(n):
            for j in range(i + 1, n):
                total_variance += 2 * default_corr * sector_risks[i] * sector_risks[j]

    return math.sqrt(total_variance)


def calculate_available_budget(
    account_size: float,
    positions: list,
    risk_pct_per_trade: float = DEFAULT_RISK_PCT,
) -> dict:
    """Calculate available risk budget for new positions.

    Args:
        account_size: Total account value.
        positions: Current positions.
        risk_pct_per_trade: Risk percentage for new trade.

    Returns:
        Dictionary with budget metrics and recommended size.
    """
    metrics = calculate_portfolio_metrics(positions, account_size)
    sectors = calculate_sector_exposure(positions, account_size)

    # Remaining exposure capacity
    max_exposure = account_size * MAX_TOTAL_EXPOSURE_PCT
    remaining_exposure = max(0, max_exposure - metrics["total_value"])

    # Max single position
    max_single = account_size * MAX_SINGLE_POSITION_PCT

    # Effective max for new position
    max_new_position = min(remaining_exposure, max_single)

    # Risk budget
    risk_for_new_trade = account_size * risk_pct_per_trade

    # Sector limits
    sector_room: dict = {}
    max_sector_value = account_size * MAX_CORRELATED_PCT
    for sector, data in sectors.items():
        room = max(0, max_sector_value - data["total_value"])
        sector_room[sector] = room

    return {
        "remaining_exposure": remaining_exposure,
        "max_single_position": max_single,
        "max_new_position": max_new_position,
        "risk_budget": risk_for_new_trade,
        "sector_room": sector_room,
        "can_add_position": remaining_exposure > 0,
    }


# ── Report Formatting ──────────────────────────────────────────────

def fmt(val: float, decimals: int = 2) -> str:
    """Format a number with commas."""
    return f"{val:,.{decimals}f}"


def print_header(title: str) -> None:
    """Print a section header."""
    width = 68
    print(f"\n{'=' * width}")
    print(f"  {title}")
    print(f"{'=' * width}")


def print_portfolio_report(
    positions: list,
    account_size: float,
) -> None:
    """Print the complete portfolio risk dashboard.

    Args:
        positions: List of Position objects.
        account_size: Total account value.
    """
    metrics = calculate_portfolio_metrics(positions, account_size)
    sectors = calculate_sector_exposure(positions, account_size)
    corr_risk = calculate_correlation_adjusted_risk(positions)
    budget = calculate_available_budget(account_size, positions)

    # ── Account Overview ────────────────────────────────────────
    print_header("PORTFOLIO RISK DASHBOARD")
    print(f"  Account Size:          ${fmt(account_size)}")
    print(f"  Total Invested:        ${fmt(metrics['total_value'])} ({metrics['exposure_pct']:.1f}%)")
    print(f"  Cash Available:        ${fmt(metrics['cash'])} ({metrics['cash_pct']:.1f}%)")
    print(f"  Unrealized P&L:        ${fmt(metrics['total_pnl'])} ({metrics['total_pnl'] / account_size * 100:+.2f}%)")
    print(f"  Active Positions:      {metrics['num_positions']}")

    # ── Per-Position Breakdown ──────────────────────────────────
    print_header("POSITION BREAKDOWN")
    header = f"  {'Symbol':<8} {'Value':>10} {'% Acct':>8} {'P&L':>10} {'P&L%':>8} {'Risk$':>10} {'Risk%':>8} {'Sector':<10}"
    print(header)
    print(f"  {'-' * 74}")

    for p in sorted(positions, key=lambda x: x.position_value, reverse=True):
        pct_acct = (p.position_value / account_size) * 100
        risk_pct_acct = (p.total_risk / account_size) * 100
        print(
            f"  {p.symbol:<8} "
            f"${fmt(p.position_value):>9} "
            f"{pct_acct:>7.1f}% "
            f"${fmt(p.unrealized_pnl):>9} "
            f"{p.unrealized_pnl_pct:>+7.1f}% "
            f"${fmt(p.total_risk):>9} "
            f"{risk_pct_acct:>7.1f}% "
            f"{p.sector:<10}"
        )

    print(f"  {'-' * 74}")
    total_risk_pct = (metrics['total_risk'] / account_size) * 100
    print(
        f"  {'TOTAL':<8} "
        f"${fmt(metrics['total_value']):>9} "
        f"{metrics['exposure_pct']:>7.1f}% "
        f"${fmt(metrics['total_pnl']):>9} "
        f"{'':>8} "
        f"${fmt(metrics['total_risk']):>9} "
        f"{total_risk_pct:>7.1f}% "
    )

    # ── Risk Analysis ───────────────────────────────────────────
    print_header("RISK ANALYSIS")
    print(f"  Simple Total Risk:          ${fmt(metrics['total_risk'])} ({total_risk_pct:.1f}% of account)")
    print(f"  Correlation-Adjusted Risk:  ${fmt(corr_risk)} ({corr_risk / account_size * 100:.1f}% of account)")
    print(f"  Diversification Benefit:    ${fmt(metrics['total_risk'] - corr_risk)} saved by diversification")

    if metrics["total_risk"] > 0:
        div_ratio = corr_risk / metrics["total_risk"]
        print(f"  Diversification Ratio:      {div_ratio:.2f} (1.0 = no benefit, lower = better)")

    # ── Sector Exposure ─────────────────────────────────────────
    print_header("SECTOR EXPOSURE")
    print(f"  {'Sector':<12} {'Positions':<20} {'Value':>10} {'% Acct':>8} {'Risk$':>10} {'Limit':>10}")
    print(f"  {'-' * 70}")

    max_sector = account_size * MAX_CORRELATED_PCT
    for sector, data in sorted(sectors.items(), key=lambda x: x[1]["total_value"], reverse=True):
        pos_str = ", ".join(data["positions"])
        over = " OVER" if data["total_value"] > max_sector else ""
        print(
            f"  {sector:<12} "
            f"{pos_str:<20} "
            f"${fmt(data['total_value']):>9} "
            f"{data['exposure_pct']:>7.1f}% "
            f"${fmt(data['total_risk']):>9} "
            f"${fmt(max_sector):>9}{over}"
        )

    # ── Portfolio Limit Checks ──────────────────────────────────
    print_header("LIMIT CHECKS")

    checks = [
        (
            "Total exposure < 70%",
            metrics["exposure_pct"] <= MAX_TOTAL_EXPOSURE_PCT * 100,
            f"{metrics['exposure_pct']:.1f}%",
        ),
        (
            "Each position < 10%",
            all((p.position_value / account_size) * 100 <= MAX_SINGLE_POSITION_PCT * 100 for p in positions),
            f"max {max((p.position_value / account_size) * 100 for p in positions):.1f}%" if positions else "N/A",
        ),
    ]

    # Check each sector
    for sector, data in sectors.items():
        ok = data["exposure_pct"] <= MAX_CORRELATED_PCT * 100
        checks.append((
            f"{sector} sector < 25%",
            ok,
            f"{data['exposure_pct']:.1f}%",
        ))

    for label, passed, detail in checks:
        status = "PASS" if passed else "FAIL"
        print(f"  [{status}] {label:<35} ({detail})")

    # ── Available Budget ────────────────────────────────────────
    print_header("AVAILABLE BUDGET FOR NEXT TRADE")
    print(f"  Remaining exposure capacity:    ${fmt(budget['remaining_exposure'])}")
    print(f"  Max single position:            ${fmt(budget['max_single_position'])}")
    print(f"  Max new position value:         ${fmt(budget['max_new_position'])}")
    print(f"  Risk budget (2% of account):    ${fmt(budget['risk_budget'])}")

    if budget["can_add_position"]:
        print(f"\n  You can open a new position up to ${fmt(budget['max_new_position'])} in value.")
        print(f"  With 2% risk ({fmt(budget['risk_budget'])} USD), and a 10% stop,")
        print(f"  that allows ~${fmt(budget['risk_budget'] / 0.10)} notional position.")
    else:
        print("\n  Portfolio is at maximum exposure. Close or reduce a position before adding new ones.")

    if budget["sector_room"]:
        print("\n  Room by sector before hitting 25% limit:")
        for sector, room in sorted(budget["sector_room"].items(), key=lambda x: x[1]):
            print(f"    {sector:<12} ${fmt(room)} remaining")


# ── Main ────────────────────────────────────────────────────────────

def main() -> None:
    """Run the portfolio sizer with demo or configured data."""
    positions = get_demo_positions()

    if ACCOUNT_SIZE <= 0:
        print("Error: ACCOUNT_SIZE must be positive")
        sys.exit(1)

    print("Using demo portfolio (5 positions)")
    print(f"Account size: ${fmt(ACCOUNT_SIZE)} (set ACCOUNT_SIZE env var to change)")

    print_portfolio_report(positions, ACCOUNT_SIZE)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""Position size calculator using multiple sizing methods.

Calculates position size using fixed fractional, volatility-adjusted,
Kelly criterion, and liquidity-constrained methods. Shows the binding
constraint and provides a formatted report.

Usage:
    python scripts/size_calculator.py

    Or with environment variables:
    ACCOUNT_SIZE=10000 ENTRY_PRICE=1.50 STOP_LOSS=1.30 python scripts/size_calculator.py

Dependencies:
    None (pure math, no external packages required)

Environment Variables:
    ACCOUNT_SIZE:    Account value in USD (default: 10000)
    ENTRY_PRICE:     Entry price per unit (default: 1.50)
    STOP_LOSS:       Stop loss price per unit (default: 1.30)
    WIN_RATE:        Historical win rate 0-1 (default: 0.55)
    AVG_WIN_RATIO:   Average win / average loss ratio (default: 1.8)
    POOL_LIQUIDITY:  Total pool liquidity in USD (default: 50000)
    ATR_VALUE:       14-period ATR in price units (default: 0.12)
    TARGET_VOL_PCT:  Target daily portfolio vol as decimal (default: 0.02)
    FEE_RATE:        One-way trading fee as decimal (default: 0.003)
    SLIPPAGE_EST:    Estimated slippage as decimal (default: 0.005)
"""

import os
import sys
from typing import Optional


# ── Configuration ───────────────────────────────────────────────────

def get_float_env(name: str, default: float) -> float:
    """Read a float from an environment variable with a default."""
    val = os.getenv(name, "")
    if not val:
        return default
    try:
        return float(val)
    except ValueError:
        print(f"Warning: {name}='{val}' is not a valid number, using default {default}")
        return default


ACCOUNT_SIZE = get_float_env("ACCOUNT_SIZE", 10_000.0)
ENTRY_PRICE = get_float_env("ENTRY_PRICE", 1.50)
STOP_LOSS = get_float_env("STOP_LOSS", 1.30)
WIN_RATE = get_float_env("WIN_RATE", 0.55)
AVG_WIN_RATIO = get_float_env("AVG_WIN_RATIO", 1.8)
POOL_LIQUIDITY = get_float_env("POOL_LIQUIDITY", 50_000.0)
ATR_VALUE = get_float_env("ATR_VALUE", 0.12)
TARGET_VOL_PCT = get_float_env("TARGET_VOL_PCT", 0.02)
FEE_RATE = get_float_env("FEE_RATE", 0.003)
SLIPPAGE_EST = get_float_env("SLIPPAGE_EST", 0.005)


# ── Fixed Fractional Sizing ────────────────────────────────────────

def fixed_fractional(
    account: float,
    risk_pct: float,
    entry: float,
    stop: float,
    fee_rate: float = 0.0,
    slippage: float = 0.0,
) -> dict:
    """Calculate position size using fixed fractional method.

    Args:
        account: Total account value.
        risk_pct: Fraction of account to risk (e.g., 0.02 for 2%).
        entry: Entry price per unit.
        stop: Stop loss price per unit.
        fee_rate: One-way fee rate (applied to entry and exit).
        slippage: Estimated slippage as fraction of entry price.

    Returns:
        Dictionary with units, value, risk_amount, and effective_risk.
    """
    risk_amount = account * risk_pct
    price_risk = abs(entry - stop)
    fee_cost = entry * fee_rate * 2  # round-trip fees
    slippage_cost = entry * slippage
    effective_risk = price_risk + fee_cost + slippage_cost

    if effective_risk <= 0:
        return {"units": 0.0, "value": 0.0, "risk_amount": risk_amount, "effective_risk": 0.0}

    units = risk_amount / effective_risk
    value = units * entry

    return {
        "units": units,
        "value": value,
        "risk_amount": risk_amount,
        "effective_risk": effective_risk,
        "price_risk": price_risk,
        "fee_cost": fee_cost,
        "slippage_cost": slippage_cost,
    }


# ── Volatility-Adjusted Sizing ─────────────────────────────────────

def volatility_adjusted(
    account: float,
    target_vol_pct: float,
    atr: float,
    entry: float,
) -> dict:
    """Calculate position size scaled by volatility.

    Args:
        account: Total account value.
        target_vol_pct: Target daily portfolio volatility as decimal.
        atr: Average True Range (14-period) in price units.
        entry: Current price per unit.

    Returns:
        Dictionary with units, value, and volatility metrics.
    """
    if atr <= 0:
        return {"units": 0.0, "value": 0.0, "daily_vol_pct": 0.0, "expected_daily_pnl": 0.0}

    target_daily_pnl = account * target_vol_pct
    daily_vol_pct = atr / entry
    units = target_daily_pnl / atr
    value = units * entry
    expected_daily_pnl = units * atr

    return {
        "units": units,
        "value": value,
        "daily_vol_pct": daily_vol_pct,
        "expected_daily_pnl": expected_daily_pnl,
        "target_daily_pnl": target_daily_pnl,
    }


# ── Kelly Criterion Sizing ─────────────────────────────────────────

def kelly_criterion(
    account: float,
    win_rate: float,
    payoff_ratio: float,
    entry: float,
    stop: float,
    fraction: float = 0.25,
) -> dict:
    """Calculate position size using Kelly criterion.

    Args:
        account: Total account value.
        win_rate: Probability of winning trade (0-1).
        payoff_ratio: Average win / average loss.
        entry: Entry price per unit.
        stop: Stop loss price per unit.
        fraction: Kelly fraction to use (0.25 recommended).

    Returns:
        Dictionary with full Kelly, fractional Kelly, units, and value.
    """
    q = 1.0 - win_rate
    if payoff_ratio <= 0:
        return {
            "full_kelly": 0.0, "fractional_kelly": 0.0, "fraction_used": fraction,
            "units": 0.0, "value": 0.0, "has_edge": False,
        }

    full_kelly = (win_rate * payoff_ratio - q) / payoff_ratio
    has_edge = full_kelly > 0
    fractional_kelly = max(0.0, full_kelly * fraction)

    price_risk = abs(entry - stop)
    if price_risk <= 0 or not has_edge:
        units = 0.0
    else:
        risk_amount = account * fractional_kelly
        units = risk_amount / price_risk

    value = units * entry

    return {
        "full_kelly": full_kelly,
        "fractional_kelly": fractional_kelly,
        "fraction_used": fraction,
        "units": units,
        "value": value,
        "has_edge": has_edge,
        "expected_growth_fraction": fractional_kelly * (2 - fractional_kelly / max(full_kelly, 1e-9)),
    }


# ── Liquidity-Constrained Sizing ───────────────────────────────────

def liquidity_constrained(
    pool_liquidity: float,
    max_slippage_pct: float,
    entry: float,
) -> dict:
    """Calculate maximum position size based on pool liquidity.

    Args:
        pool_liquidity: Total pool liquidity in USD.
        max_slippage_pct: Maximum acceptable slippage as decimal.
        entry: Token price per unit.

    Returns:
        Dictionary with max_value, max_units, and expected slippage.
    """
    if pool_liquidity <= 0 or entry <= 0:
        return {"max_value": 0.0, "max_units": 0.0, "expected_slippage_pct": 0.0}

    max_value = pool_liquidity * max_slippage_pct
    max_units = max_value / entry
    expected_slippage_pct = max_slippage_pct

    return {
        "max_value": max_value,
        "max_units": max_units,
        "expected_slippage_pct": expected_slippage_pct,
        "pool_liquidity": pool_liquidity,
        "position_as_pct_of_pool": (max_value / pool_liquidity) * 100,
    }


# ── R:R Targets ────────────────────────────────────────────────────

def calculate_rr_targets(
    entry: float,
    stop: float,
    units: float,
) -> list:
    """Calculate reward-to-risk targets for a given position.

    Args:
        entry: Entry price.
        stop: Stop loss price.
        units: Number of units in position.

    Returns:
        List of dicts with R multiple, target price, and P&L.
    """
    risk_per_unit = abs(entry - stop)
    direction = 1 if entry > stop else -1  # long if stop below entry
    targets = []

    for r_multiple in [1.0, 1.5, 2.0, 3.0, 5.0]:
        target_price = entry + direction * risk_per_unit * r_multiple
        pnl = units * direction * (target_price - entry)
        targets.append({
            "r_multiple": r_multiple,
            "target_price": round(target_price, 6),
            "pnl": round(pnl, 2),
        })

    return targets


# ── Report Formatting ──────────────────────────────────────────────

def format_number(val: float, decimals: int = 2) -> str:
    """Format a number with commas and specified decimals."""
    return f"{val:,.{decimals}f}"


def print_header(title: str) -> None:
    """Print a section header."""
    width = 60
    print(f"\n{'=' * width}")
    print(f"  {title}")
    print(f"{'=' * width}")


def print_row(label: str, value: str, width: int = 40) -> None:
    """Print a label-value row."""
    print(f"  {label:<{width}} {value}")


def print_report(
    account: float,
    entry: float,
    stop: float,
    win_rate: float,
    payoff_ratio: float,
    pool_liquidity: float,
    atr: float,
    target_vol_pct: float,
    fee_rate: float,
    slippage_est: float,
) -> None:
    """Print the complete position sizing report.

    Args:
        account: Account value in USD.
        entry: Entry price per unit.
        stop: Stop loss price per unit.
        win_rate: Historical win rate (0-1).
        payoff_ratio: Avg win / avg loss.
        pool_liquidity: Pool liquidity in USD.
        atr: 14-period ATR in price units.
        target_vol_pct: Target daily vol as decimal.
        fee_rate: One-way fee rate.
        slippage_est: Estimated slippage fraction.
    """
    # ── Input Summary ───────────────────────────────────────────
    print_header("POSITION SIZE CALCULATOR")
    print_row("Account Size", f"${format_number(account)}")
    print_row("Entry Price", f"${format_number(entry, 6)}")
    print_row("Stop Loss", f"${format_number(stop, 6)}")
    print_row("Price Risk", f"${format_number(abs(entry - stop), 6)} ({abs(entry - stop) / entry * 100:.1f}%)")
    print_row("Win Rate", f"{win_rate * 100:.1f}%")
    print_row("Payoff Ratio", f"{payoff_ratio:.2f}x")
    print_row("Pool Liquidity", f"${format_number(pool_liquidity)}")
    print_row("ATR(14)", f"${format_number(atr, 6)}")
    print_row("Fee Rate (one-way)", f"{fee_rate * 100:.2f}%")
    print_row("Slippage Estimate", f"{slippage_est * 100:.2f}%")

    # ── Fixed Fractional ────────────────────────────────────────
    print_header("METHOD 1: FIXED FRACTIONAL")
    results_ff = {}
    for risk_pct in [0.01, 0.02, 0.03]:
        ff = fixed_fractional(account, risk_pct, entry, stop, fee_rate, slippage_est)
        results_ff[risk_pct] = ff
        label = f"{risk_pct * 100:.0f}% risk"
        print_row(
            label,
            f"{format_number(ff['units'])} units | ${format_number(ff['value'])} value | ${format_number(ff['risk_amount'])} at risk",
        )
    ff_default = results_ff[0.02]
    print(f"\n  Fee-adjusted risk per unit: ${format_number(ff_default['effective_risk'], 4)}")
    print(f"  (Price risk ${format_number(ff_default['price_risk'], 4)} + fees ${format_number(ff_default['fee_cost'], 4)} + slippage ${format_number(ff_default['slippage_cost'], 4)})")

    # ── Volatility-Adjusted ─────────────────────────────────────
    print_header("METHOD 2: VOLATILITY-ADJUSTED")
    va = volatility_adjusted(account, target_vol_pct, atr, entry)
    print_row("Daily Vol (ATR/Price)", f"{va['daily_vol_pct'] * 100:.1f}%")
    print_row("Target Daily PnL", f"${format_number(va['target_daily_pnl'])}")
    print_row("Position Size", f"{format_number(va['units'])} units")
    print_row("Position Value", f"${format_number(va['value'])}")
    print_row("Expected Daily PnL Range", f"+/- ${format_number(va['expected_daily_pnl'])}")

    # ── Kelly Criterion ─────────────────────────────────────────
    print_header("METHOD 3: KELLY CRITERION")
    kelly_results = {}
    for frac, label in [(1.0, "Full Kelly"), (0.5, "Half Kelly"), (0.25, "Quarter Kelly")]:
        kc = kelly_criterion(account, win_rate, payoff_ratio, entry, stop, frac)
        kelly_results[frac] = kc
        edge_str = "" if kc["has_edge"] else " [NO EDGE]"
        print_row(
            f"{label} ({frac:.0%})",
            f"{kc['fractional_kelly'] * 100:.1f}% risk | {format_number(kc['units'])} units | ${format_number(kc['value'])}{edge_str}",
        )
    full_kc = kelly_results[1.0]
    print(f"\n  Full Kelly fraction: {full_kc['full_kelly'] * 100:.2f}%")
    if not full_kc["has_edge"]:
        print("  *** NEGATIVE KELLY: No statistical edge detected. Do not trade. ***")
    else:
        print("  Recommendation: Use Quarter Kelly (0.25x) as default")

    # ── Liquidity-Constrained ───────────────────────────────────
    print_header("METHOD 4: LIQUIDITY-CONSTRAINED")
    liq_results = {}
    for slip_pct in [0.01, 0.02, 0.05]:
        lc = liquidity_constrained(pool_liquidity, slip_pct, entry)
        liq_results[slip_pct] = lc
        print_row(
            f"{slip_pct * 100:.0f}% max slippage",
            f"{format_number(lc['max_units'])} units | ${format_number(lc['max_value'])} max value | {lc['position_as_pct_of_pool']:.1f}% of pool",
        )

    # ── Combined Recommendation ─────────────────────────────────
    print_header("RECOMMENDATION (BINDING CONSTRAINT)")

    candidates = {
        "Fixed Fractional (2%)": ff_default["units"],
        "Volatility-Adjusted": va["units"],
        "Quarter Kelly": kelly_results[0.25]["units"],
        "Liquidity (2% slip)": liq_results[0.02]["max_units"],
    }

    # Filter out zero/negative
    valid = {k: v for k, v in candidates.items() if v > 0}
    if not valid:
        print("  No valid position size found. Check inputs.")
        return

    binding_method = min(valid, key=valid.get)
    recommended_units = valid[binding_method]
    recommended_value = recommended_units * entry
    pct_of_account = (recommended_value / account) * 100

    print_row("Binding Constraint", binding_method)
    print_row("Recommended Size", f"{format_number(recommended_units)} units")
    print_row("Position Value", f"${format_number(recommended_value)}")
    print_row("% of Account", f"{pct_of_account:.1f}%")

    # Check portfolio limits
    print("\n  Portfolio limit checks:")
    single_ok = pct_of_account <= 10
    print(f"    Single position < 10%: {'PASS' if single_ok else 'FAIL'} ({pct_of_account:.1f}%)")

    print("\n  All methods compared:")
    for method, units in sorted(candidates.items(), key=lambda x: x[1]):
        marker = " <-- BINDING" if method == binding_method else ""
        val = units * entry
        print(f"    {method:<30} {format_number(units):>12} units  ${format_number(val):>12}{marker}")

    # ── R:R Targets ─────────────────────────────────────────────
    print_header("R:R TARGETS (at recommended size)")
    risk_per_unit = abs(entry - stop)
    risk_total = recommended_units * risk_per_unit
    targets = calculate_rr_targets(entry, stop, recommended_units)

    print_row("Risk per trade", f"${format_number(risk_total)}")
    print()
    print(f"  {'R:R':<8} {'Target Price':<16} {'P&L':<16} {'% of Account'}")
    print(f"  {'-' * 56}")
    for t in targets:
        pct = (t["pnl"] / account) * 100
        print(f"  {t['r_multiple']:<8.1f} ${format_number(t['target_price'], 6):<14} ${format_number(t['pnl']):<14} {pct:+.2f}%")


# ── Validation ──────────────────────────────────────────────────────

def validate_inputs(
    account: float,
    entry: float,
    stop: float,
    win_rate: float,
    payoff_ratio: float,
    pool_liquidity: float,
) -> list:
    """Validate inputs and return list of warning messages.

    Args:
        account: Account size.
        entry: Entry price.
        stop: Stop loss price.
        win_rate: Win rate (0-1).
        payoff_ratio: Avg win / avg loss.
        pool_liquidity: Pool liquidity.

    Returns:
        List of warning/error strings. Empty list means all OK.
    """
    errors: list = []
    if account <= 0:
        errors.append("Account size must be positive")
    if entry <= 0:
        errors.append("Entry price must be positive")
    if stop <= 0:
        errors.append("Stop loss must be positive")
    if entry == stop:
        errors.append("Entry and stop loss cannot be the same price")
    if not 0 < win_rate < 1:
        errors.append(f"Win rate must be between 0 and 1, got {win_rate}")
    if payoff_ratio <= 0:
        errors.append("Payoff ratio must be positive")
    if pool_liquidity <= 0:
        errors.append("Pool liquidity must be positive")

    # Warnings (non-fatal)
    risk_pct = abs(entry - stop) / entry * 100
    if risk_pct > 30:
        errors.append(f"Warning: Stop distance is {risk_pct:.1f}% from entry (very wide)")
    if pool_liquidity < account * 0.1:
        errors.append("Warning: Pool liquidity is less than 10% of account size")

    return errors


# ── Main ────────────────────────────────────────────────────────────

def main() -> None:
    """Run the position size calculator with configured parameters."""
    issues = validate_inputs(
        ACCOUNT_SIZE, ENTRY_PRICE, STOP_LOSS,
        WIN_RATE, AVG_WIN_RATIO, POOL_LIQUIDITY,
    )

    fatal = [i for i in issues if not i.startswith("Warning")]
    warnings = [i for i in issues if i.startswith("Warning")]

    if fatal:
        print("Input errors:")
        for e in fatal:
            print(f"  - {e}")
        sys.exit(1)

    if warnings:
        print("Warnings:")
        for w in warnings:
            print(f"  - {w}")

    print_report(
        account=ACCOUNT_SIZE,
        entry=ENTRY_PRICE,
        stop=STOP_LOSS,
        win_rate=WIN_RATE,
        payoff_ratio=AVG_WIN_RATIO,
        pool_liquidity=POOL_LIQUIDITY,
        atr=ATR_VALUE,
        target_vol_pct=TARGET_VOL_PCT,
        fee_rate=FEE_RATE,
        slippage_est=SLIPPAGE_EST,
    )


if __name__ == "__main__":
    main()