Fájl részletek

Előnézet (első 120 sor)

from __future__ import annotations

from collections import Counter, deque

from dataclasses import dataclass, asdict
from typing import Any, Dict, List, Optional, Tuple
import math


# ============================================================
# Saturnus v2.1 canonical rule engine
# ------------------------------------------------------------
# Main goals:
# - STANDARD / RECOVERY / PANIC / CATASTROPHE decision model
# - Trend-aware PANIC rules
# - Profit invariant for STANDARD and RECOVERY exits
# - Panic context tracking
# - Safe defaults and robust missing-key handling
# - Multiple entry-point aliases for easier drop-in integration
# ============================================================


# -----------------------------
# Helpers
# -----------------------------
def _f(value: Any, default: float = 0.0) -> float:
    try:
        if value is None:
            return float(default)
        return float(value)
    except Exception:
        return float(default)


def _i(value: Any, default: int = 0) -> int:
    try:
        if value is None:
            return int(default)
        return int(value)
    except Exception:
        return int(default)


def _b(value: Any, default: bool = False) -> bool:
    if isinstance(value, bool):
        return value
    if value is None:
        return default
    if isinstance(value, (int, float)):
        return bool(value)
    s = str(value).strip().lower()
    if s in ("1", "true", "yes", "y", "on"):
        return True
    if s in ("0", "false", "no", "n", "off", ""):
        return False
    return default


def _s(value: Any, default: str = "") -> str:
    if value is None:
        return default
    return str(value)


def _clean_float(value: float) -> Optional[float]:
    if value is None:
        return None
    if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
        return None
    return float(value)


def _pct(value: Any, default: float = 0.0) -> float:
    """
    Accepts both:
    - 0.03  => 3%
    - 3     => 3%
    Converts everything to decimal form.
    """
    v = _f(value, default)
    if abs(v) >= 1.0:
        return v / 100.0
    return v


def _first_present(d: Dict[str, Any], keys: List[str], default: Any = None) -> Any:
    for k in keys:
        if k in d and d[k] is not None:
            return d[k]
    return default


def _max_valid(values: List[Optional[float]]) -> Optional[float]:
    vals = [v for v in values if v is not None]
    return max(vals) if vals else None


def _min_valid(values: List[Optional[float]]) -> Optional[float]:
    vals = [v for v in values if v is not None]
    return min(vals) if vals else None


# -----------------------------
# Data models
# -----------------------------
@dataclass
class EngineContext:
    base: float
    last: float
    prev_last: float
    peak: float
    trough: float
    in_position: bool

    ma_short: float
    ma_long: float
    ma_sideways_band_pct: float

    fee_pct_per_side: float
    fee_total_pct: float

Csak változott diff sorok

Teljes diff