marketmyna 0.2.0__py3-none-any.whl

marketmyna/strategies/one_yang_three_yin.yaml

@@ -0,0 +1,37 @@
+# One Yang Three Yin Strategy / 一阳夹三阴
+# K-line pattern: bullish → 3 small bearish → bullish. Consolidation end signal.
+
+name: one_yang_three_yin
+display_name: 一阳夹三阴
+description: 检测一阳夹三阴K线整理形态，趋势延续入场信号。
+category: pattern
+core_rules: [2, 4]
+required_tools:
+  - fetch_history
+  - technical_summary
+aliases: [一阳穿三阴, 一阳夹三阴]
+default_priority: 110
+
+instructions: |
+  **一阳夹三阴（One Yang Three Yin Strategy）**
+
+  形态定义（最近 5 个交易日）：
+
+  1. **第1日**：大阳线（收盘价 > 开盘价，实体 > 股价的 2%）。
+  2. **第2-4日**：连续三根阴线或小K线：
+     - 每根K线最低价不跌破第1日开盘价。
+     - 成交量应逐步萎缩（量比 < 0.8）。
+     - 三根K线应收在第1日实体范围内。
+  3. **第5日**：又一根阳线，收盘价突破第1日收盘价。
+
+  如何使用工具评估：
+
+  1. 使用 `get_daily_history` 获取最近 10 日数据。
+  2. 检查最后 5 根K线是否符合上述形态。
+  3. 使用 `analyze_trend` 确认多头排列（关联理念2：趋势交易，MA5 > MA10 > MA20）。
+
+  评分调整：
+  - 形态成立 + 趋势看多：sentiment_score +15
+  - 形态成立但趋势不明：sentiment_score +5
+  - 在 `pattern_analysis` 和 `buy_reason` 中注明"一阳夹三阴"。
+  - 理想买点设在第5日收盘价附近，止损设在第1日开盘价下方。

marketmyna/strategies/shrink_pullback.yaml

@@ -0,0 +1,46 @@
+# Shrink Volume Pullback Strategy / 缩量回踩
+# Volume shrinks during pullback to MA5/MA10, then price bounces.
+
+name: shrink_pullback
+display_name: 缩量回踩
+description: 检测缩量回踩均线支撑信号，趋势延续的理想入场点。
+category: trend
+core_rules: [1, 2, 4]
+required_tools:
+  - fetch_history
+  - technical_summary
+  - fetch_quote
+aliases: [缩量回踩, 回踩]
+default_router: true
+default_priority: 40
+market_regimes: [trending_down, sideways]
+
+instructions: |
+  **缩量回踩（Shrink Volume Pullback Strategy）**
+
+  入场判定标准：
+
+  1. **前提条件**（关联理念2：趋势交易）：
+     - 股票必须处于上升趋势（MA5 > MA10 > MA20）。
+     - 使用 `analyze_trend` 确认多头排列。
+
+  2. **回踩检测**（关联理念4：买点偏好）：
+     - 使用 `get_daily_history` 和 `get_realtime_quote`。
+     - 价格回踩至 MA5 附近（误差 1% 以内）或 MA10 附近（误差 2% 以内）。
+     - 回调期间成交量 < 5 日均量的 70%（缩量特征）。
+     - `analyze_trend` → volume_status 应显示缩量。
+
+  3. **反弹信号**（关联理念1：严进策略）：
+     - 当前价格守住均线支撑位。
+     - MA5 乖离率 < 2% — 最佳买入区间。
+
+  4. **确认条件**（关联理念5：风险排查）：
+     - `search_stock_news` 无利空消息。
+     - 筹码分布健康（获利比例 50-80%）。
+
+  评分调整：
+  - 缩量回踩 MA5：sentiment_score +10
+  - 缩量回踩 MA10 且量能 < 0.6 倍均量：sentiment_score +8
+  - 理想买点设在 MA5 水平，次优买点设在 MA10。
+  - 止损设在 MA20 水平。
+  - 在 `buy_reason` 中注明"缩量回踩"。

marketmyna/strategies/volume_breakout.yaml

@@ -0,0 +1,47 @@
+# Volume Breakout Strategy / 放量突破
+# Price breaks above resistance on heavy volume (>2x average).
+
+name: volume_breakout
+display_name: 放量突破
+description: 检测放量突破阻力位信号。适用于股价接近已知阻力位时。
+category: trend
+core_rules: [1, 2, 3]
+required_tools:
+  - fetch_history
+  - technical_summary
+  - fetch_quote
+aliases: [放量突破, 突破]
+default_priority: 30
+market_regimes: [trending_up]
+
+instructions: |
+  **放量突破（Volume Breakout Strategy）**
+
+  突破判定标准：
+
+  1. **阻力位识别**：
+     - 使用 `analyze_trend` → resistance_levels 获取阻力位。
+     - 通常为 20 日高点或前期震荡平台顶部。
+
+  2. **量能确认**（关联理念3：效率优先）：
+     - 当日成交量 > 5 日均量的 2 倍。
+     - 使用 `get_realtime_quote` → volume_ratio > 2.0 确认。
+     - 使用 `get_daily_history` 计算均量进行交叉验证。
+
+  3. **价格确认**（关联理念1：严进策略）：
+     - 收盘价必须站上阻力位。
+     - 收盘应在当日振幅上方 30%（强势收盘）。
+     - 突破后乖离率检查：仍需 < 5%，避免追高。
+
+  4. **后续验证**（如有数据）：
+     - 次日开盘应在突破位之上，区分真突破与假突破。
+
+  5. **风险过滤**（关联理念5：风险排查）：
+     - 通过 `search_stock_news` 检查无重大利空。
+     - PE 不应过高（避免泡沫型突破）。
+
+  评分调整：
+  - 放量突破确认：sentiment_score +12
+  - 突破伴随板块共振（板块也走强）：额外 +5
+  - 理想买点设在突破位附近，止损设在突破位下方 3%。
+  - 在 `buy_reason` 和 `volume_analysis` 中注明"放量突破"。

marketmyna/strategies/wave_theory.yaml

@@ -0,0 +1,64 @@
+# Elliott Wave Theory Strategy / 波浪理论
+# 5-wave impulse + 3-wave corrective pattern analysis for trend and position sizing.
+
+name: wave_theory
+display_name: 波浪理论
+description: 基于艾略特波浪理论的推动浪与调整浪结构，判断当前所处浪型与潜在目标价。
+category: framework
+core_rules: [1, 2, 3, 4]
+required_tools:
+  - fetch_history
+  - technical_summary
+  - fetch_quote
+aliases: [波浪, 波浪理论, 艾略特]
+default_priority: 80
+market_regimes: [volatile]
+
+instructions: |
+  **波浪理论（Elliott Wave Theory）**
+
+  核心原则：市场按照 5 浪推进 + 3 浪调整的循环结构运行。
+
+  ## 分析步骤
+
+  ### 1. 识别当前浪型
+  使用 `get_daily_history` 获取近 120 日数据，结合 `analyze_trend` 趋势数据：
+
+  **推动浪（1-3-5）识别特征**：
+  - 第1浪：趋势反转的第一波，成交量温和放大。
+  - 第3浪：最强劲的推动浪，通常放大量，MACD 强势；绝不是最短浪。
+  - 第5浪：量能往往弱于第3浪，出现顶背离则走高后即将结束。
+
+  **调整浪（A-B-C）识别特征**：
+  - A 浪：第一次下跌，成交量较大，多数人以为是回调。
+  - B 浪：反弹，力度弱于前期涨幅，成交量萎缩，陷阱风险高。
+  - C 浪：第二次下跌，力度往往超过 A 浪，完成调整。
+
+  ### 2. 黄金位置判断
+  - 第2浪回调通常在第1浪的 38.2%~61.8%。
+  - 第3浪目标通常是第1浪的 1.618~2.618 倍延伸。
+  - 第4浪不得进入第1浪价格区域（违反波浪规则）。
+  - C浪目标：A 浪顶端起算，等于或超过 A 浪长度。
+
+  ### 3. 最优买点
+  - **第2浪回调企稳**（黄金坑）：最安全买点，止损第1浪起点。
+  - **第4浪回调企稳**：次优，止损第1浪顶部。
+  - **第3浪初期突破**：放量突破第1浪高点时。
+  - 避免在第5浪末端追高（顶背离风险）。
+
+  ### 4. 风险提示
+  - B浪反弹不宜重仓（陷阱性质）。
+  - 波浪计数存在主观性，需结合其他技术指标验证。
+  - 若波浪规则被违反（如第4浪侵入第1浪），需重新归数。
+
+  ### 5. 输出要求
+  - 给出当前可能的浪型位置（如："处于第3浪中段"或"疑似第4浪调整"）。
+  - 给出关键斐波那契支撑/阻力位（0.382/0.618/1.618）。
+  - 说明当前是买入时机、等待机会还是规避。
+  - 标注波浪计数的置信度（高/中/低）。
+
+  评分调整建议：
+  - 第2浪底部企稳（黄金坑）：`sentiment_score +15`
+  - 第3浪突破确认：`sentiment_score +12`
+  - 第5浪末端/顶背离：`sentiment_score -10`
+  - C浪下跌中：`sentiment_score -12`

marketmyna/trading/__init__.py

@@ -0,0 +1,2 @@
+"""Trade section: intraday charts, price alerts, position sizing and the
+trade journal. Read-only - nothing here places orders."""

marketmyna/trading/alerts.py

@@ -0,0 +1,356 @@
+"""Price / indicator alerts for traders.
+
+AlertMonitor polls quotes for symbols with active alerts (only while their
+market is open), evaluates each alert and sends the ones that fire through
+the NotificationDispatcher's "alert" route (Telegram, push, ...).
+
+Firing rules:
+- one-shot alert: fires once, then status "triggered";
+- repeating alert: fires, then re-arms only after the condition has been
+  false again (so a price hovering on a level doesn't spam), and never
+  more often than its cooldown.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from datetime import datetime, timedelta
+from typing import Callable, Optional
+from zoneinfo import ZoneInfo
+
+import pandas as pd
+
+from ..utils.deadline import call_with_deadline
+from . import indicators as ind
+from .market_hours import is_open, timezone_of
+
+logger = logging.getLogger(__name__)
+
+# kind -> (label, value unit, needs daily history)
+KINDS: dict[str, tuple[str, str, bool]] = {
+    "price_above": ("Price rises to or above", "price", False),
+    "price_below": ("Price falls to or below", "price", False),
+    "pct_up": ("Up today by at least", "%", False),
+    "pct_down": ("Down today by at least", "%", False),
+    "rsi_above": ("Daily RSI(14) at or above", "rsi", True),
+    "rsi_below": ("Daily RSI(14) at or below", "rsi", True),
+    "volume_spike": ("Volume today at least", "x avg", True),
+    "high_breakout": ("Breaks above the N-day high", "days", True),
+    "low_breakdown": ("Breaks below the N-day low", "days", True),
+}
+
+DEFAULT_POLL_SECONDS = 60
+DAILY_TTL = timedelta(minutes=30)
+
+
+def _completed_days(daily: pd.DataFrame, market: str, now: datetime) -> pd.DataFrame:
+    """Daily bars without today's (still forming) bar."""
+    if daily.empty:
+        return daily
+    last = pd.DatetimeIndex(daily.index)[-1]
+    today = now.astimezone(ZoneInfo(timezone_of(market))).date()
+    return daily.iloc[:-1] if last.date() >= today else daily
+
+
+def measure(kind: str, value: float, quote: dict, daily: Optional[pd.DataFrame], market: str,
+            now: datetime) -> tuple[Optional[float], bool, str]:
+    """(observed number, condition met, human description of the observation)."""
+    price = quote.get("price")
+    if price is None:
+        return None, False, "no price"
+    if kind == "price_above":
+        return price, price >= value, f"price {price:,.2f}"
+    if kind == "price_below":
+        return price, price <= value, f"price {price:,.2f}"
+    change = quote.get("change_percent")
+    if kind in ("pct_up", "pct_down"):
+        if change is None:
+            return None, False, "no day change"
+        met = change >= abs(value) if kind == "pct_up" else change <= -abs(value)
+        return change, met, f"{change:+.2f}% today"
+    if daily is None or daily.empty:
+        return None, False, "no history"
+    past = _completed_days(daily, market, now)
+    if kind in ("rsi_above", "rsi_below"):
+        closes = pd.concat([past["close"].astype(float), pd.Series([float(price)])], ignore_index=True)
+        r = ind.rsi(closes).iloc[-1]
+        if pd.isna(r):
+            return None, False, "not enough history"
+        met = r >= value if kind == "rsi_above" else r <= value
+        return float(r), met, f"RSI {r:.1f}"
+    if kind == "volume_spike":
+        avg = float(past["volume"].tail(20).mean()) if "volume" in past else 0.0
+        vol = quote.get("volume")
+        if not avg or vol is None:
+            return None, False, "no volume data"
+        ratio = float(vol) / avg
+        return ratio, ratio >= value, f"volume {ratio:.1f}x the 20-day average"
+    if kind in ("high_breakout", "low_breakdown"):
+        n = max(2, int(value))
+        window = past.tail(n)
+        if len(window) < n:
+            return None, False, "not enough history"
+        if kind == "high_breakout":
+            level = float(window["high"].max())
+            return price, price > level, f"price {price:,.2f} vs {n}-day high {level:,.2f}"
+        level = float(window["low"].min())
+        return price, price < level, f"price {price:,.2f} vs {n}-day low {level:,.2f}"
+    return None, False, f"unknown alert kind {kind}"
+
+
+def describe(kind: str, value: float) -> str:
+    label, unit, _ = KINDS.get(kind, (kind, "", False))
+    if unit == "price":
+        return f"{label} {value:,.2f}"
+    if unit == "%":
+        return f"{label} {abs(value):g}%"
+    if unit == "x avg":
+        return f"{label} {value:g}x its 20-day average"
+    if unit == "days":
+        return label.replace("N-day", f"{int(value)}-day")
+    return f"{label} {value:g}"
+
+
+def step(alert: dict, met: bool, now: datetime) -> tuple[bool, dict]:
+    """Pure state transition -> (fire?, field updates)."""
+    updates: dict = {}
+    if alert.get("expires_at") and now >= alert["expires_at"]:
+        return False, {"status": "expired"}
+    if met and alert.get("armed", True):
+        last = alert.get("last_triggered_at")
+        cooldown = timedelta(minutes=alert.get("cooldown_minutes") or 0)
+        if alert.get("repeat") and last and now - last < cooldown:
+            return False, updates
+        updates.update(last_triggered_at=now, trigger_count=(alert.get("trigger_count") or 0) + 1)
+        if alert.get("repeat"):
+            updates["armed"] = False
+        else:
+            updates["status"] = "triggered"
+        return True, updates
+    if not met and alert.get("repeat") and not alert.get("armed", True):
+        updates["armed"] = True
+    return False, updates
+
+
+def _default_quote(symbol: str, market: str) -> dict:
+    from ..agent.agents import _resolve_fetcher
+
+    return _resolve_fetcher(market).get_quote(symbol) or {}
+
+
+def _default_daily(symbol: str, market: str) -> pd.DataFrame:
+    from ..agent.agents import _resolve_fetcher
+
+    df = _resolve_fetcher(market).get_history(symbol, period="6mo")
+    return df.rename(columns=str.lower)
+
+
+class AlertMonitor:
+    def __init__(
+        self,
+        config,
+        poll_seconds: int = DEFAULT_POLL_SECONDS,
+        quote_fn: Callable[[str, str], dict] = _default_quote,
+        daily_fn: Callable[[str, str], pd.DataFrame] = _default_daily,
+        dispatcher=None,
+    ):
+        self._config = config
+        self._poll = max(15, int(poll_seconds))
+        self._quote_fn = quote_fn
+        self._daily_fn = daily_fn
+        self._dispatcher = dispatcher
+        self._daily_cache: dict[tuple[str, str], tuple[datetime, pd.DataFrame]] = {}
+        self._stop = threading.Event()
+        self._thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+    # ---- lifecycle
+    def start(self) -> None:
+        if self._thread and self._thread.is_alive():
+            return
+        self._stop.clear()
+        self._thread = threading.Thread(target=self._loop, name="alert-monitor", daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        self._stop.set()
+        if self._thread:
+            self._thread.join(timeout=5)
+
+    def is_running(self) -> bool:
+        return bool(self._thread and self._thread.is_alive())
+
+    def _loop(self) -> None:
+        from ..core import tenant
+        from ..services.accounts import for_each_user
+
+        while not self._stop.wait(self._poll):
+            try:
+                # One pass over every user's alerts (quotes fetched once per
+                # symbol); each fired alert is sent in its owner's scope.
+                with tenant.system_scope():
+                    self.tick()
+            except Exception:
+                logger.exception("Alert check failed")
+            # Per-user settings and state: run once per user in accounts mode.
+            try:
+                from .scanner import run_saved_scans
+
+                for_each_user(self._config, lambda: run_saved_scans(self._config, dispatcher=self._dispatcher),
+                              "Saved scan run")
+            except Exception:
+                logger.exception("Saved scan run failed")
+            try:
+                from .risk import check_daily_limit
+
+                for_each_user(self._config, lambda: check_daily_limit(self._config, dispatcher=self._dispatcher),
+                              "Daily risk check")
+            except Exception:
+                logger.exception("Daily risk check failed")
+            try:
+                from ..services.calendar import check_reminders
+
+                for_each_user(self._config, lambda: check_reminders(self._config, dispatcher=self._dispatcher),
+                              "Calendar reminder")
+                from ..services.calendar import (
+                    check_earnings_results,
+                    check_event_alerts,
+                    check_results,
+                )
+                from ..services.thesis import check_alerts as check_theses
+
+                for_each_user(self._config, lambda: check_theses(self._config, dispatcher=self._dispatcher),
+                              "Thesis check")
+
+                for_each_user(self._config, lambda: check_earnings_results(self._config, dispatcher=self._dispatcher),
+                              "Results are out")
+
+                for_each_user(self._config, lambda: check_event_alerts(self._config, dispatcher=self._dispatcher),
+                              "Event alerts")
+
+                for_each_user(self._config, lambda: check_results(self._config, dispatcher=self._dispatcher),
+                              "Release results")
+            except Exception:
+                logger.exception("Calendar reminder failed")
+            try:
+                from ..data.nse_deals import maybe_refresh
+
+                maybe_refresh()
+            except Exception:
+                logger.exception("NSE deals refresh failed")
+
+    # ---- one pass
+    def _db(self):
+        from ..storage import DatabaseManager, get_db_url
+
+        return DatabaseManager.instance(get_db_url(config=self._config))
+
+    def _daily(self, symbol: str, market: str, now: datetime) -> Optional[pd.DataFrame]:
+        key = (symbol, market)
+        cached = self._daily_cache.get(key)
+        if cached and now - cached[0] < DAILY_TTL:
+            return cached[1]
+        try:
+            df = call_with_deadline(self._daily_fn, 30, symbol, market)
+        except Exception as exc:
+            logger.warning("Daily history for %s unavailable: %s", symbol, exc)
+            return cached[1] if cached else None
+        self._daily_cache[key] = (now, df)
+        return df
+
+    def tick(self, now: Optional[datetime] = None, force: bool = False) -> dict:
+        """Check every active alert once. `force` ignores market hours (the
+        "Check now" button). Returns {"checked": n, "fired": [...], "skipped_closed": n}."""
+        from ..storage import PriceAlertEventRecord, PriceAlertRecord
+
+        with self._lock:
+            now = now or datetime.now()
+            with self._db().get_session() as session:
+                alerts = [
+                    {c.name: getattr(r, c.name) for c in PriceAlertRecord.__table__.columns}
+                    for r in session.query(PriceAlertRecord).filter(PriceAlertRecord.status == "active")
+                ]
+            groups: dict[tuple[str, str], list[dict]] = {}
+            for a in alerts:
+                groups.setdefault((a["symbol"], a["market"]), []).append(a)
+
+            fired, updates, skipped = [], {}, 0
+            aware_now = now.astimezone() if now.tzinfo is None else now
+            for (symbol, market), items in groups.items():
+                if not force and not is_open(market, aware_now):
+                    skipped += len(items)
+                    continue
+                try:
+                    quote = call_with_deadline(self._quote_fn, 20, symbol, market) or {}
+                except Exception as exc:
+                    logger.warning("Quote for %s (%s) failed: %s", symbol, market, exc)
+                    continue
+                daily = None
+                if any(KINDS.get(a["kind"], ("", "", False))[2] for a in items):
+                    daily = self._daily(symbol, market, now)
+                for a in items:
+                    observed, met, text = measure(a["kind"], a["value"], quote, daily, market, aware_now)
+                    fire, change = step(a, met, now)
+                    change.update(last_checked_at=now, last_value=observed)
+                    updates[a["id"]] = change
+                    if fire:
+                        fired.append({"alert": a, "quote": quote, "observed": text})
+
+            deliveries = [self._notify_as_owner(f) for f in fired]
+            with self._db().get_session() as session:
+                for alert_id, change in updates.items():
+                    rec = session.get(PriceAlertRecord, alert_id)
+                    if rec is not None:
+                        for k, v in change.items():
+                            setattr(rec, k, v)
+                for f, (message, delivery) in zip(fired, deliveries):
+                    a = f["alert"]
+                    session.add(PriceAlertEventRecord(
+                        user_id=a.get("user_id"), alert_id=a["id"], symbol=a["symbol"], market=a["market"], kind=a["kind"],
+                        message=message, price=f["quote"].get("price"), delivery=delivery, created_at=now,
+                    ))
+            return {
+                "checked": sum(len(v) for v in groups.values()) - skipped,
+                "skipped_closed": skipped,
+                "fired": [{"id": f["alert"]["id"], "symbol": f["alert"]["symbol"], "observed": f["observed"]} for f in fired],
+            }
+
+    def _notify_as_owner(self, f: dict) -> tuple[str, dict]:
+        """In accounts mode, deliver as the alert's owner so it reaches only
+        their channels (the monitor itself runs in the system scope)."""
+        from ..core import tenant
+
+        user_id = f["alert"].get("user_id")
+        if not tenant.enabled() or user_id is None:
+            return self._notify(f)
+        with tenant.user_scope(user_id):
+            return self._notify(f)
+
+    def _notify(self, f: dict) -> tuple[str, dict]:
+        from ..services.report import CURRENCY_SYMBOLS
+
+        a, q = f["alert"], f["quote"]
+        cur = CURRENCY_SYMBOLS.get(a["market"], "")
+        price = q.get("price")
+        change = q.get("change_percent")
+        head = f"🔔 {a['symbol']}"
+        if price is not None:
+            head += f" {cur}{price:,.2f}"
+        if change is not None:
+            head += f" ({change:+.2f}%)"
+        lines = [head, f"{describe(a['kind'], a['value'])}: {f['observed']}"]
+        if a.get("note"):
+            lines.append(f"📝 {a['note']}")
+        if a.get("repeat"):
+            lines.append("Repeating alert: re-arms once the condition clears.")
+        message = "\n".join(lines)
+        try:
+            from ..notifiers.dispatcher import NotificationDispatcher
+
+            dispatcher = self._dispatcher or NotificationDispatcher(self._config)
+            delivery = dispatcher.send_all(message, title=f"Alert: {a['symbol']}", purpose="alert")
+        except Exception as exc:
+            logger.error("Alert notification failed: %s", exc)
+            delivery = {}
+        return message, delivery