288 lines
9.4 KiB
Python
288 lines
9.4 KiB
Python
"""R:R Scanner service.
|
||
|
||
Scans tracked tickers for asymmetric risk-reward trade setups.
|
||
Long: target = nearest SR above, stop = entry - ATR × multiplier.
|
||
Short: target = nearest SR below, stop = entry + ATR × multiplier.
|
||
Filters by configurable R:R threshold (default 3:1).
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import logging
|
||
from datetime import datetime, timezone
|
||
|
||
from sqlalchemy import delete, select
|
||
from sqlalchemy.ext.asyncio import AsyncSession
|
||
|
||
from app.exceptions import NotFoundError
|
||
from app.models.score import CompositeScore
|
||
from app.models.sr_level import SRLevel
|
||
from app.models.ticker import Ticker
|
||
from app.models.trade_setup import TradeSetup
|
||
from app.services.indicator_service import _extract_ohlcv, compute_atr
|
||
from app.services.price_service import query_ohlcv
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
|
||
async def _get_ticker(db: AsyncSession, symbol: str) -> Ticker:
|
||
normalised = symbol.strip().upper()
|
||
result = await db.execute(select(Ticker).where(Ticker.symbol == normalised))
|
||
ticker = result.scalar_one_or_none()
|
||
if ticker is None:
|
||
raise NotFoundError(f"Ticker not found: {normalised}")
|
||
return ticker
|
||
|
||
|
||
def _compute_quality_score(
|
||
rr: float,
|
||
strength: int,
|
||
distance: float,
|
||
entry_price: float,
|
||
*,
|
||
w_rr: float = 0.35,
|
||
w_strength: float = 0.35,
|
||
w_proximity: float = 0.30,
|
||
rr_cap: float = 10.0,
|
||
) -> float:
|
||
"""Compute a quality score for a candidate S/R level.
|
||
|
||
Combines normalized R:R ratio, level strength, and proximity to entry
|
||
into a single 0–1 score using configurable weights.
|
||
"""
|
||
norm_rr = min(rr / rr_cap, 1.0)
|
||
norm_strength = strength / 100.0
|
||
norm_proximity = 1.0 - min(distance / entry_price, 1.0)
|
||
return w_rr * norm_rr + w_strength * norm_strength + w_proximity * norm_proximity
|
||
|
||
|
||
async def scan_ticker(
|
||
db: AsyncSession,
|
||
symbol: str,
|
||
rr_threshold: float = 1.5,
|
||
atr_multiplier: float = 1.5,
|
||
) -> list[TradeSetup]:
|
||
"""Scan a single ticker for trade setups meeting the R:R threshold.
|
||
|
||
1. Fetch OHLCV data and compute ATR.
|
||
2. Fetch SR levels.
|
||
3. Compute long and short setups.
|
||
4. Filter by R:R threshold.
|
||
5. Delete old setups for this ticker and persist new ones.
|
||
|
||
Returns list of persisted TradeSetup models.
|
||
"""
|
||
ticker = await _get_ticker(db, symbol)
|
||
|
||
# Fetch OHLCV
|
||
records = await query_ohlcv(db, symbol)
|
||
if not records or len(records) < 15:
|
||
logger.info(
|
||
"Skipping %s: insufficient OHLCV data (%d bars, need 15+)",
|
||
symbol, len(records),
|
||
)
|
||
# Clear any stale setups
|
||
await db.execute(
|
||
delete(TradeSetup).where(TradeSetup.ticker_id == ticker.id)
|
||
)
|
||
return []
|
||
|
||
_, highs, lows, closes, _ = _extract_ohlcv(records)
|
||
entry_price = closes[-1]
|
||
|
||
# Compute ATR
|
||
try:
|
||
atr_result = compute_atr(highs, lows, closes)
|
||
atr_value = atr_result["atr"]
|
||
except Exception:
|
||
logger.info("Skipping %s: cannot compute ATR", symbol)
|
||
await db.execute(
|
||
delete(TradeSetup).where(TradeSetup.ticker_id == ticker.id)
|
||
)
|
||
return []
|
||
|
||
if atr_value <= 0:
|
||
logger.info("Skipping %s: ATR is zero or negative", symbol)
|
||
await db.execute(
|
||
delete(TradeSetup).where(TradeSetup.ticker_id == ticker.id)
|
||
)
|
||
return []
|
||
|
||
# Fetch SR levels from DB (already computed by sr_service)
|
||
sr_result = await db.execute(
|
||
select(SRLevel).where(SRLevel.ticker_id == ticker.id)
|
||
)
|
||
sr_levels = list(sr_result.scalars().all())
|
||
|
||
if not sr_levels:
|
||
logger.info("Skipping %s: no SR levels available", symbol)
|
||
await db.execute(
|
||
delete(TradeSetup).where(TradeSetup.ticker_id == ticker.id)
|
||
)
|
||
return []
|
||
|
||
levels_above = sorted(
|
||
[lv for lv in sr_levels if lv.price_level > entry_price],
|
||
key=lambda lv: lv.price_level,
|
||
)
|
||
levels_below = sorted(
|
||
[lv for lv in sr_levels if lv.price_level < entry_price],
|
||
key=lambda lv: lv.price_level,
|
||
reverse=True,
|
||
)
|
||
|
||
# Get composite score for this ticker
|
||
comp_result = await db.execute(
|
||
select(CompositeScore).where(CompositeScore.ticker_id == ticker.id)
|
||
)
|
||
comp = comp_result.scalar_one_or_none()
|
||
composite_score = comp.score if comp else 0.0
|
||
|
||
now = datetime.now(timezone.utc)
|
||
setups: list[TradeSetup] = []
|
||
|
||
# Long setup: target = nearest SR above, stop = entry - ATR × multiplier
|
||
# Check all resistance levels above and pick the one with the best quality score
|
||
if levels_above:
|
||
stop = entry_price - (atr_value * atr_multiplier)
|
||
risk = entry_price - stop
|
||
if risk > 0:
|
||
best_quality = 0.0
|
||
best_candidate_rr = 0.0
|
||
best_candidate_target = 0.0
|
||
for lv in levels_above:
|
||
reward = lv.price_level - entry_price
|
||
if reward > 0:
|
||
rr = reward / risk
|
||
if rr >= rr_threshold:
|
||
distance = lv.price_level - entry_price
|
||
quality = _compute_quality_score(rr, lv.strength, distance, entry_price)
|
||
if quality > best_quality:
|
||
best_quality = quality
|
||
best_candidate_rr = rr
|
||
best_candidate_target = lv.price_level
|
||
if best_candidate_rr > 0:
|
||
setups.append(TradeSetup(
|
||
ticker_id=ticker.id,
|
||
direction="long",
|
||
entry_price=round(entry_price, 4),
|
||
stop_loss=round(stop, 4),
|
||
target=round(best_candidate_target, 4),
|
||
rr_ratio=round(best_candidate_rr, 4),
|
||
composite_score=round(composite_score, 4),
|
||
detected_at=now,
|
||
))
|
||
|
||
# Short setup: target = nearest SR below, stop = entry + ATR × multiplier
|
||
# Check all support levels below and pick the one with the best quality score
|
||
if levels_below:
|
||
stop = entry_price + (atr_value * atr_multiplier)
|
||
risk = stop - entry_price
|
||
if risk > 0:
|
||
best_quality = 0.0
|
||
best_candidate_rr = 0.0
|
||
best_candidate_target = 0.0
|
||
for lv in levels_below:
|
||
reward = entry_price - lv.price_level
|
||
if reward > 0:
|
||
rr = reward / risk
|
||
if rr >= rr_threshold:
|
||
distance = entry_price - lv.price_level
|
||
quality = _compute_quality_score(rr, lv.strength, distance, entry_price)
|
||
if quality > best_quality:
|
||
best_quality = quality
|
||
best_candidate_rr = rr
|
||
best_candidate_target = lv.price_level
|
||
if best_candidate_rr > 0:
|
||
setups.append(TradeSetup(
|
||
ticker_id=ticker.id,
|
||
direction="short",
|
||
entry_price=round(entry_price, 4),
|
||
stop_loss=round(stop, 4),
|
||
target=round(best_candidate_target, 4),
|
||
rr_ratio=round(best_candidate_rr, 4),
|
||
composite_score=round(composite_score, 4),
|
||
detected_at=now,
|
||
))
|
||
|
||
# Delete old setups for this ticker, persist new ones
|
||
await db.execute(
|
||
delete(TradeSetup).where(TradeSetup.ticker_id == ticker.id)
|
||
)
|
||
for setup in setups:
|
||
db.add(setup)
|
||
|
||
await db.commit()
|
||
|
||
# Refresh to get IDs
|
||
for s in setups:
|
||
await db.refresh(s)
|
||
|
||
return setups
|
||
|
||
|
||
async def scan_all_tickers(
|
||
db: AsyncSession,
|
||
rr_threshold: float = 1.5,
|
||
atr_multiplier: float = 1.5,
|
||
) -> list[TradeSetup]:
|
||
"""Scan all tracked tickers for trade setups.
|
||
|
||
Processes each ticker independently — one failure doesn't stop others.
|
||
Returns all setups found across all tickers.
|
||
"""
|
||
result = await db.execute(select(Ticker).order_by(Ticker.symbol))
|
||
tickers = list(result.scalars().all())
|
||
|
||
all_setups: list[TradeSetup] = []
|
||
for ticker in tickers:
|
||
try:
|
||
setups = await scan_ticker(
|
||
db, ticker.symbol, rr_threshold, atr_multiplier
|
||
)
|
||
all_setups.extend(setups)
|
||
except Exception:
|
||
logger.exception("Error scanning ticker %s", ticker.symbol)
|
||
|
||
return all_setups
|
||
|
||
|
||
async def get_trade_setups(
|
||
db: AsyncSession,
|
||
direction: str | None = None,
|
||
) -> list[dict]:
|
||
"""Get all stored trade setups, optionally filtered by direction.
|
||
|
||
Returns dicts sorted by R:R desc, secondary composite desc.
|
||
Each dict includes the ticker symbol.
|
||
"""
|
||
stmt = (
|
||
select(TradeSetup, Ticker.symbol)
|
||
.join(Ticker, TradeSetup.ticker_id == Ticker.id)
|
||
)
|
||
if direction is not None:
|
||
stmt = stmt.where(TradeSetup.direction == direction.lower())
|
||
|
||
stmt = stmt.order_by(
|
||
TradeSetup.rr_ratio.desc(),
|
||
TradeSetup.composite_score.desc(),
|
||
)
|
||
|
||
result = await db.execute(stmt)
|
||
rows = result.all()
|
||
|
||
return [
|
||
{
|
||
"id": setup.id,
|
||
"symbol": symbol,
|
||
"direction": setup.direction,
|
||
"entry_price": setup.entry_price,
|
||
"stop_loss": setup.stop_loss,
|
||
"target": setup.target,
|
||
"rr_ratio": setup.rr_ratio,
|
||
"composite_score": setup.composite_score,
|
||
"detected_at": setup.detected_at,
|
||
}
|
||
for setup, symbol in rows
|
||
]
|