harry/ForexBot2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Daily-trend veto on M15 + lot-size / already-open lines (campaign 2026-09-30), and the 2026-10-01 whole-codebase bug review

Browse Source 
Two bodies of work that touch the same files, so one commit.

Direction and setup-size campaign (2026-09-30 → 10-01, owner's RISK-FIRST rule,
written before the runs):
- SIGNAL: M15 daily-trend veto (factory override 7, xau_strategy.daily_trend_veto
  "both"). A finished setup against a clear daily trend (closed D1 bars, Sunday
  stubs dropped; close vs its 50-bar EMA AND vs the close 60 kept days earlier)
  is removed as the last step of the core. One definition
  (signal_aggregator.daily_trend_series) for live, the bar replay and the twin's
  host side; D1 is a required frame of the M15 scan; mirrored in
  cuda_signal_kernels.py K2. W3 824 / +205.12R / PF 1.73 / max DD 12.4R vs
  1105 / +195.79R / 1.49 / 20.9R; 2019 → 2026 1473 / +223.33R / 1.42 / 41.5R vs
  2091 / +192.53R / 1.24 / 64.8R; unseen holdout −4.62R vs −6.63R.
- FAILED, not shipped: the veto on M5 (W3 drawdown 10.1R → 15.2R) and on H1
  (−9.7R), buy-only and sell-only on M15, the wide-stop cap
  (xau_strategy.wide_stop_cap_atr stays 0.0, a research knob).
- New M15 pins: W2 dfc647ee…, OOS e87b6de1…, W3 ad3b0dbd…. M5 / H1 / H4 pins
  unchanged. --set xau_strategy.daily_trend_veto=off reproduces the previous M15
  pins byte for byte. Twin and reference script MD5-equal on every window;
  recorder and feature-export parity re-proved; base-rate table rebuilt.
- DISPLAY (books byte-identical): exposure.py — the lot size for
  trade_size.risk_per_trade (new config.json block, off by default, private to
  the owner) and the count of alerted same-direction plans still open
  (signals.alerted_at, read-only open_alerted_setups); the daily trend in words
  on Telegram, the CLI and the dashboard; signals.daily_trend logged.
- providers/oanda: a date window with no bars is an empty page, not an error
  (a D1 pad starting on a Saturday could not be fetched).
- Reports only, nothing shipped: seven context screens (no state nominated) and
  eight outside data sources (none adds a forecast to gold's own daily trend).
- Independent verification (report section 5.13): every figure reproduced on
  both scripts, scoring identical to the previous commit on all four
  timeframes, no look-ahead. Caveats recorded there: this is a risk filter, not
  a more accurate direction call; nine tenths of the 2019 → 2026 gain is 2022;
  the neighbour clause is thin (a simple 100-day average misses the R line by
  1.2R); "never adds a trade" is an observation, not a guarantee.

Bug review of the whole codebase (2026-10-01). Signal path clean. 17 defects
elsewhere, plus 4 found by an independent review of the fixes; all fixed, each
with a test; no trade book changed:
- telegram_bot: one _deliver_alert for the candle scan and the level break. The
  row is stamped alerted_at BEFORE the send, on a one-worker alert-db pool, and
  un-stamped when no chat received it or the task is cancelled mid-stamp, so
  two alerts at one candle close count each other and no SQLite write runs on
  the event loop. The 5-bar cooldown counts bars of the scan's own frame
  (== gpu_backtest._apply_cooldown; clock time released the 22:00 UTC bar after
  the settlement pause) and is restored from signals.db at start-up. The
  lot-size line goes to the owner's own chat only (a group the owner ran
  /autoscan in used to receive it). /status gains a news-model line and escapes
  failure details.
- signal_log: mark_alerted returns the stamp it wrote; unmark_alerted;
  last_alerted_bars (read-only).
- advisory_outcome: candle continuity is judged bar by bar inside the walk; a
  hole after a trade's exit no longer voids it. The stored-candle replay
  resolves 108 of 111 logged setups instead of 99, all equal to the live
  resolver's R.
- providers/oanda: an empty date window is accepted only when it is 5 days or
  shorter and no malformed candle was skipped; a longer one is retried, then
  refused, instead of being cached as history with a hole.
- news_engine: blank RSS titles skipped; one unreadable headline no longer
  costs the local model its whole batch (checked on the real bundle); model
  health recorded; no DeepSeek audit call in a process that does not archive;
  event-direction cache keyed per release; peek_week_events never fetches.
- llm_client: chat_json never raises and never logs the API key (requests
  quotes the Authorization value in InvalidHeader; error bodies are redacted).
- signal_aggregator: the scan's news block is guarded; the replay path
  (use_news=False) assigns exactly the values it did before.
- agent_panel: PANEL_PROMPT_VERSION v2.2 — same prompt text, corrected input
  (event timing over the cached calendar week, headlines newest first).
  scripts/panel_replay.py replays the logged payload per persona;
  scripts/label_scan_outcomes.py counts with an ISO cutoff.
- test_all.py: no ALTER TABLE … DROP COLUMN (the live box has SQLite 3.34);
  tests that write Parquet print a notice and return without pyarrow.

Verification after the last code change: suite 632 passed, 0 failed (also with
both Parquet engines blocked and FB2_BACKEND=cpu, the live box's view); the
five reference MD5s reproduce on both backtesters, 0 cache fallbacks; Module 37
green; static Python 3.9 / SQLite 3.34 check clean on every touched file.

Evidence: backtest/research/daily_trend_campaign_2026-09-30.md,
context_screens_2026-10.md, new_inputs_2026-10.md; CLAUDE.md sections 2, 4, 6,
8, 9, 10 and 11; pair_signals/xauusd.py docstring (M15 override 7).

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
This commit is contained in:
Harwinder Sekhon
2026-10-01 10:28:28 -04:00
parent 0c56b4e155
commit 1793d9167a
31 changed files with 6021 additions and 286 deletions
Download Patch File Download Diff File Expand all files Collapse all files
telegram_bot.py
+275 -43
View File
@@ -74,11 +74,13 @@ from app_config import (
from providers import BaseDataProvider, make_data_provider
from providers.base import _is_daily_maintenance
from agent_panel import attach_panel, panel_health
from exposure import attach_exposure, size_shared
from llm_client import get_llm_client
from news_engine import FundamentalContext, NewsEngine
from pair_signals import PAIR_PRODUCERS
from signal_aggregator import SignalAggregator, SignalReport
from signal_log import gate_reason
from signal_log import (gate_reason, last_alerted_bars, mark_alerted,
unmark_alerted)
from violent_watch import attach_watch, should_send_headsup
if TYPE_CHECKING: # type hints only — ViolentWatch is never needed at runtime here
@@ -199,6 +201,16 @@ TF_CONFIRMATIONS = {
}
_executor = ThreadPoolExecutor(max_workers=4)
# ONE worker for an alert's database steps (refresh the "already open" line,
# stamp the row as alerted, undo the stamp). A single worker is the mutual
# exclusion: one alert's read and write run back to back, in arrival order,
# so of two alerts sent at the same candle close the second counts the
# first. It also keeps SQLite off the event loop (the logger's lock can be
# held for seconds by the outcome labeller) and never queues behind the
# scan pool above. Not an asyncio.Lock: on Python 3.9 one created at
# import binds to a loop that is not the running one.
_alert_db_executor = ThreadPoolExecutor(
max_workers=1, thread_name_prefix="alert-db")
# ── Markdown escaping ─────────────────────────────────────────────────
@@ -409,7 +421,23 @@ def _plain_words_line(report: SignalReport) -> str:
f"Reliability: *{reliability_words(report.final_confidence)}* · {agree}")
def format_signal_message(report: SignalReport) -> str:
def _daily_trend_line(report: SignalReport) -> str:
""""🧭 Daily trend: rising — this buy goes with it" (main.daily_trend_words,
the same words on every surface), or "" when the scan carries no daily
trend. On M15 a plan against a clear daily trend never reaches an
alert (the core removes it); on the other timeframes the line is
information only."""
from main import daily_trend_words # display helper, no side effects
words = daily_trend_words(report)
return f"🧭 {_escape_md(words)}" if words else ""
def format_signal_message(report: SignalReport, channel: bool = False) -> str:
"""The alert / scan text. `channel=True` builds the copy for every
audience but the owner's own chat (the subscriber channel, a group
the bot was switched on in): identical, except that the lot-size line
(which reveals the owner's risk per trade) is left out unless
config.json sets trade_size.telegram_channel."""
sig = report.final_signal
emoji = _SIGNAL_EMOJI.get(sig, "⬜")
qe = _QUALITY_EMOJI.get(report.signal_quality, "")
@@ -431,6 +459,9 @@ def format_signal_message(report: SignalReport) -> str:
_plain_words_line(report),
f"📊 Regime: {regime_str} · Vol: {vol_str}",
]
trend_line = _daily_trend_line(report)
if trend_line:
lines.append(trend_line)
if report.action_recommendation:
# Pattern identifiers use underscores, which legacy Telegram Markdown
# can misparse even when escaped inside this italicized action line.
@@ -457,6 +488,15 @@ def format_signal_message(report: SignalReport) -> str:
f"▶ Entry `{_fmt_price(ts.entry_price)}`",
f"🛑 SL `{_fmt_price(ts.stop_loss)}` (${risk_usd:.2f} / {ts.risk_pips:.0f}p = 1R)",
]
# Lot size for the owner's risk limit and the alerted plans still
# open in this direction (exposure.attach_exposure stamps both
# post-hoc; empty unless configured / unless something is open).
# The size is private: the channel copy carries it only when
# config.json says so.
if report.size_line and (not channel or size_shared("telegram_channel")):
lines.append(f"📏 {_escape_md(report.size_line)}")
if report.open_line:
lines.append(f"🧱 {_escape_md(report.open_line)}")
# Trailing-stop management plan (matches backtested exit model:
# TP1 is advisory, the trail is the exit). Params are stamped on
@@ -611,7 +651,13 @@ def _run_signal_sync(
config = PAIR_PRODUCERS[symbol](timeframe, confirmation_tfs)
aggregator = SignalAggregator(config)
aggregator.data_provider = _get_shared_dp()
return aggregator.analyze_pair(symbol=symbol, log_source="telegram")
report = aggregator.analyze_pair(symbol=symbol, log_source="telegram")
# Display-only lot-size and "already open" lines (never raises; one
# read-only query on signals.db). Stamped here, on the scan executor,
# for the manual scans. An ALERT refreshes them just before it is sent
# (_deliver_alert): every timeframe scans at the same candle close, so
# the line stamped here cannot know about an alert going out beside it.
return attach_exposure(report, surface="telegram")
async def run_signal(
@@ -761,11 +807,10 @@ def _key_bar_seconds(key: str) -> Optional[int]:
return None
def _report_bar_ts(report: SignalReport) -> Optional[pd.Timestamp]:
"""The report's primary bar label as a UTC timestamp; None when it
cannot be parsed (the cooldown then does not apply)."""
def _bar_label_ts(label: Any) -> Optional[pd.Timestamp]:
"""A bar label as a UTC timestamp; None when it cannot be parsed."""
try:
ts = pd.Timestamp(report.timestamp)
ts = pd.Timestamp(label)
except Exception:
return None
if pd.isna(ts):
@@ -773,9 +818,45 @@ def _report_bar_ts(report: SignalReport) -> Optional[pd.Timestamp]:
return ts.tz_localize("UTC") if ts.tzinfo is None else ts.tz_convert("UTC")
def _report_bar_ts(report: SignalReport) -> Optional[pd.Timestamp]:
"""The report's primary bar label as a UTC timestamp; None when it
cannot be parsed (the cooldown then does not apply)."""
return _bar_label_ts(report.timestamp)
def _primary_bars_since(key: str, report: SignalReport, last: pd.Timestamp,
now_bar: pd.Timestamp) -> Optional[int]:
"""How many primary bars lie after `last`, up to and including the
report's own bar, in the frame the scan analysed (report._frames):
the backtester's position difference `pos - last_entry_pos`. None when
the report carries no frame for the key's timeframe or its bar is not
in it; the caller then falls back to clock time."""
try:
tf = Timeframe(key.rsplit("_", 1)[-1])
df = (getattr(report, "_frames", None) or {}).get(tf)
if df is None or len(df) == 0:
return None
idx = df.index
if getattr(idx, "tz", None) is None:
idx = idx.tz_localize("UTC")
if now_bar not in idx:
return None
return int(((idx > last) & (idx <= now_bar)).sum())
except Exception:
return None
def _inside_alert_cooldown(key: str, report: SignalReport) -> bool:
"""True while this key sits within _ALERT_COOLDOWN_BARS primary bars
of its last ALERTED setup's bar (the backtester's entry cooldown)."""
of its last ALERTED setup's bar (the backtester's entry cooldown).
Bars are COUNTED in the scan's own primary frame, like the
backtester's bar positions. Clock time is not the same thing: across
the daily settlement pause or the weekend an hour or two days pass
while no bar prints, and a clock rule released the 22:00 UTC bar that
no book ever enters (six M15 and three M5 entries in three years,
2026-10-01 review). Clock time remains the fallback for a report
without frames."""
last = _last_alert_bar.get(key)
if last is None or report.trade_setup is None:
return False
@@ -783,8 +864,30 @@ def _inside_alert_cooldown(key: str, report: SignalReport) -> bool:
now_bar = _report_bar_ts(report)
if secs is None or now_bar is None:
return False
elapsed = (now_bar - last).total_seconds()
return 0 <= elapsed < _ALERT_COOLDOWN_BARS * secs
if now_bar < last:
return False
bars = _primary_bars_since(key, report, last, now_bar)
if bars is not None:
return bars < _ALERT_COOLDOWN_BARS
return (now_bar - last).total_seconds() < _ALERT_COOLDOWN_BARS * secs
def _restore_alert_cooldowns(bars: Dict[Any, str]) -> int:
"""Seed the cooldown memory from signal_log.last_alerted_bars() after a
start-up: {(symbol, timeframe): bar label} of the newest alerted row.
Without it every restart forgot the last alert and the next bar could
alert again inside the 5 bars. Only the cooldown is restored; the
dedup fingerprints start empty, as before. A key already in memory is
left alone. Returns how many keys were seeded."""
restored = 0
for (symbol, timeframe), label in (bars or {}).items():
bar = _bar_label_ts(label)
key = f"{symbol}_{timeframe}"
if bar is None or key in _last_alert_bar:
continue
_last_alert_bar[key] = bar
restored += 1
return restored
@@ -844,6 +947,10 @@ def _should_alert(key: str, report: SignalReport) -> bool:
def _commit_alert(key: str, report: SignalReport) -> None:
# In-memory dedup state only. The signal-log stamp of the alert is
# written (and, for an undelivered alert, undone) by _deliver_alert on
# the alert-db worker: a database write does not belong on the event
# loop this function runs on.
_last_alert_fp[key] = _alert_fingerprint(report)
_last_alert_ts[key] = time.time()
_last_alert_quality[key] = report.signal_quality
@@ -898,17 +1005,123 @@ async def _send_alert(bot, chat_id: int, text: str) -> bool:
return False
async def _broadcast(bot, text: str) -> int:
def _is_owner_chat(chat_id: Any) -> bool:
"""True for the owner's own chat with the bot, the one audience of the
private lot-size line. The owner lock is per USER, so /autoscan or a
scan button used inside a group makes that group a target: it is not
the owner's chat and gets the copy without the size."""
return OWNER_ID is not None and chat_id == OWNER_ID
async def _broadcast(bot, text: str, channel_text: Optional[str] = None) -> int:
"""Send `text` to every signal target; returns how many chats got it.
Shared by the scan and breach paths so the delivery rule cannot
drift between them."""
drift between them. `channel_text`, when given, is what every target
except the owner's own chat receives instead (the copy without the
owner's private lot-size line)."""
delivered = 0
for chat_id in _signal_targets():
if await _send_alert(bot, chat_id, text):
body = (text if channel_text is None or _is_owner_chat(chat_id)
else channel_text)
if await _send_alert(bot, chat_id, body):
delivered += 1
return delivered
def _stamp_exposure_and_mark(report: SignalReport) -> Optional[str]:
"""On the alert-db worker: refresh the lot-size and "already open"
lines, then stamp the report's signal-log row as alerted. Read first,
write second, nothing in between: the next alert on the worker sees
this stamp. Returns the stamp to undo if no chat receives the alert
(None when nothing was written). Never raises."""
attach_exposure(report, surface="telegram")
return mark_alerted(report)
def _undo_cancelled_stamp(report: SignalReport, done: Any) -> None:
"""Done-callback of the stamp job when the alert's task was cancelled
while that job was queued or running (a shutdown, or auto-scan switched
off, at the wrong moment). Cancelling a task cannot stop a job the
worker has already started, so its stamp lands although nothing will be
sent: clear it. Runs on the alert-db worker right after the job, also
when the pool has already been told to shut down. Never raises."""
try:
if done.cancelled():
return # never ran: nothing was written
stamp = done.result()
if stamp:
unmark_alerted(report, stamp)
except Exception:
logger.warning("alert: could not clear the stamp of a cancelled "
"alert", exc_info=True)
async def _undo_alert_mark(report: SignalReport, stamp: Optional[str]) -> None:
"""The alert reached no chat: clear the stamp this attempt wrote (and
only that one), so the row does not count as a plan the reader holds.
Never raises."""
if not stamp:
return
try:
await asyncio.get_running_loop().run_in_executor(
_alert_db_executor, unmark_alerted, report, stamp)
except Exception:
logger.warning("alert: could not clear the alerted stamp of an "
"undelivered alert", exc_info=True)
async def _deliver_alert(bot, key: str, report: SignalReport, tf_label: str,
header: str = "", kind: str = "alert") -> int:
"""Send one alert: panel → exposure lines + alerted stamp → both
copies → commit. The ONE delivery path of the candle scan and the
level break; the caller holds _alert_lock(key) and has passed
_should_alert. Returns how many chats received it.
The row is stamped BEFORE the send so that an alert going out at the
same candle close on another timeframe already counts this plan in its
"already open" line (2026-10-01: stamped after the send, two alerts at
one boundary never counted each other). A send that reaches no chat
undoes the stamp and commits nothing, so the setup stays eligible for
the next scan; so does a cancellation before the send has started.
Residue: if this send fails completely after another alert has already
counted it, that alert's line is one too high."""
loop = asyncio.get_running_loop()
# Panel AFTER the quality gate + dedup decision so no LLM spend on
# suppressed alerts. Runs on the scan executor to keep the event loop
# free; this key's alert lock is held for the panel's wall time
# (≤~25 s), which only delays a same-key duplicate that _should_alert
# would drop anyway.
await loop.run_in_executor(_executor, attach_panel, report)
# submit(), not run_in_executor(): the job's own future is kept so that
# a cancellation HERE (nothing has been sent yet) can still undo the
# stamp the job writes.
job = _alert_db_executor.submit(_stamp_exposure_and_mark, report)
try:
stamp = await asyncio.wrap_future(job, loop=loop)
except asyncio.CancelledError:
job.add_done_callback(
functools.partial(_undo_cancelled_stamp, report))
raise
delivered = 0
try:
detail = header + format_signal_message(report)
delivered = await _broadcast(
bot, detail, header + format_signal_message(report, channel=True))
except Exception:
# (A cancellation is not an Exception: on shutdown mid-send a chat
# may already hold the message, so the stamp stays.)
await _undo_alert_mark(report, stamp)
raise
if not delivered:
await _undo_alert_mark(report, stamp)
return 0
# Commit only when the alert reached at least one target; a fully
# failed send stays eligible for the next scan.
_commit_alert(key, report)
logger.info(_alert_sent_line(report, tf_label, delivered, kind=kind))
return delivered
# ── Candle-boundary scheduler ────────────────────────────────────────
_autoscan_chats: Set[int] = set()
@@ -1062,20 +1275,7 @@ async def _scan_timeframe(
async with _alert_lock(key):
if not _should_alert(key, report):
continue
# Panel AFTER the quality gate + dedup decision so no LLM
# spend on suppressed alerts. Runs on the scan executor to
# keep the event loop free; this key's alert lock is held
# for the panel's wall time (≤~25 s), which only delays a
# same-key duplicate that _should_alert would drop anyway.
await asyncio.get_running_loop().run_in_executor(
_executor, attach_panel, report)
detail = format_signal_message(report)
delivered = await _broadcast(bot, detail)
# Commit only when the alert reached at least one target;
# a fully failed send stays eligible for the next scan.
if delivered:
_commit_alert(key, report)
logger.info(_alert_sent_line(report, tf.value, delivered))
await _deliver_alert(bot, key, report, tf.value)
# ── WebSocket level-breach monitor ──────────────────────────────────
@@ -1222,20 +1422,16 @@ async def _handle_breach(bot, pair_symbol: str, price: float, level_name: str) -
if not _should_alert(key, report):
return
# Same post-gate panel attach as the auto-scan path (see
# _scan_timeframe for the spend/lock rationale).
await asyncio.get_running_loop().run_in_executor(
_executor, attach_panel, report)
# The same delivery as the auto-scan path (panel, the refreshed
# "already open" line, stamp, send, commit), under the level-break
# header. The cached M15 report this path reuses can be up to a
# bar old; _deliver_alert refreshes its exposure lines.
header = (
f"⚡ *LEVEL BREAK* — {_escape_md(display)} crossed "
f"*{_escape_md(label)}* @ `{_fmt_price(price)}`\n\n"
)
detail = header + format_signal_message(report)
sent = await _broadcast(bot, detail)
if sent:
_commit_alert(key, report)
logger.info(_alert_sent_line(report, Timeframe.M15.value, sent,
kind="breach alert"))
await _deliver_alert(bot, key, report, Timeframe.M15.value,
header=header, kind="breach alert")
def _breach_task_done(task: asyncio.Task) -> None:
@@ -1517,7 +1713,9 @@ def _news_health_lines() -> List[str]:
Reads the class-level `NewsEngine._source_health` written by the
scan-path fetches plus the LLM client's health stamps — display
only, never triggers a fetch. ⚠️ marks a degraded dependency;
details live in the rotating log (transition-logged WARNINGs)."""
details live in the rotating log (transition-logged WARNINGs).
Failure details are exception text, so they are Markdown-escaped: an
unpaired underscore in one would make Telegram reject the reply."""
lines = ["\n*News & AI:*"]
# Snapshot: a scan thread may insert a source's FIRST entry while we
# iterate (dict-changed-size RuntimeError); entry mutation is safe.
@@ -1536,11 +1734,13 @@ def _news_health_lines() -> List[str]:
ff = sh.get("calendar:forexfactory")
if cal:
if NewsEngine.source_is_failing(cal):
lines.append(f" ⚠️ Calendar: unavailable — {cal['detail']}"
lines.append(" ⚠️ Calendar: unavailable — "
f"{_escape_md(str(cal['detail']))}"
f" ({_fmt_age(cal['err'])})")
elif NewsEngine.source_is_failing(ff):
lines.append(f" ⚠️ Calendar: {cal['extra']} — ForexFactory"
f" down: {ff['detail']} ({_fmt_age(ff['err'])})")
f" down: {_escape_md(str(ff['detail']))}"
f" ({_fmt_age(ff['err'])})")
else:
lines.append(f" ✅ Calendar: {cal['extra']}"
f" ({_fmt_age(cal['ok'])} ago)")
@@ -1548,13 +1748,27 @@ def _news_health_lines() -> List[str]:
if heads:
failing = NewsEngine.source_is_failing(heads)
mark = "⚠️" if failing else "✅"
detail = f" — {heads['detail']}" if failing else ""
detail = (f" — {_escape_md(str(heads['detail']))}"
if failing else "")
ts = heads["err"] if failing else heads["ok"]
lines.append(f" {mark} Headlines: {heads['extra']}{detail}"
f" ({_fmt_age(ts)} ago)")
# The local headline scorer (news_model modes fallback / primary).
# Present only in a process that ran it; a failing batch leaves the
# cycle's headlines on keyword scores, which nothing else showed.
model = sh.get("news_model")
if model:
if NewsEngine.source_is_failing(model):
lines.append(" ⚠️ News model: not scoring — "
f"{_escape_md(str(model['detail']))}"
f" ({_fmt_age(model['err'])})")
else:
lines.append(f" ✅ News model: {model['extra']}"
f" ({_fmt_age(model['ok'])} ago)")
for name, entry in sorted(sh.items()):
if name.startswith("rss:") and NewsEngine.source_is_failing(entry):
lines.append(f" ⚠️ {name[4:]}: {entry['detail']}"
lines.append(f" ⚠️ {_escape_md(name[4:])}: "
f"{_escape_md(str(entry['detail']))}"
f" ({_fmt_age(entry['err'])})")
client = get_llm_client()
if not client.available:
@@ -1786,7 +2000,12 @@ async def cb_scan(update: Update, context: ContextTypes.DEFAULT_TYPE) -> None:
try:
report = await run_signal(btn["symbol"], btn["tf"])
text = format_signal_message(report)
# The reply lands in the chat the button was pressed in. Only the
# owner's own chat gets the private lot-size line; the owner
# pressing it inside a group must not show the group their risk.
chat = update.effective_chat
text = format_signal_message(
report, channel=not _is_owner_chat(chat.id if chat else None))
except Exception as exc:
logger.exception("Signal scan failed")
text = f"❌ Scan failed: {_escape_md(str(exc))}"
@@ -1914,6 +2133,18 @@ async def _post_init(app: Application) -> None:
if CHAT_ID:
_autoscan_chats.add(int(CHAT_ID))
# The 5-bar entry cooldown lives in memory; seed it from the signal log
# so a restart (a deploy, the weekly timer) cannot re-alert inside it.
# Before the feed check: /autoscan can start the loops later.
try:
bars = await asyncio.get_running_loop().run_in_executor(
_alert_db_executor, last_alerted_bars)
restored = _restore_alert_cooldowns(bars)
logger.info(f"Alert cooldown restored from the signal log: "
f"{restored} timeframe(s)")
except Exception:
logger.exception("Alert cooldown restore failed — starting without it")
if not _feed_active():
logger.info("Neither TELEGRAM_CHAT_ID nor TELEGRAM_CHANNEL_ID set — "
"auto-scan disabled on boot. Use /autoscan in chat to enable.")
@@ -1980,6 +2211,7 @@ async def _post_shutdown(app: Application) -> None:
logger.info("Shutting down ForexBot2...")
_stop_scheduler()
_executor.shutdown(wait=False)
_alert_db_executor.shutdown(wait=False)
logger.info("Shutdown complete")