alphaforged 0.3.2__py3-none-any.whl

alphaforge/__init__.py

@@ -0,0 +1,5 @@
+"""AlphaForge platform scaffold."""
+
+__all__ = ["__version__"]
+
+__version__ = "0.1.0"

alphaforge/alerting/__init__.py

@@ -0,0 +1 @@
+"""Multi-channel alerting system for AlphaForge signals."""

alphaforge/alerting/channels.py

@@ -0,0 +1,245 @@
+"""Alert channel implementations — Telegram, Email, Webhook.
+
+Each channel implements the AlertChannel ABC with a single `send()` method.
+Channels are configured via environment variables or constructor args.
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import smtplib
+import ssl
+import urllib.request
+import urllib.error
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AlertMessage:
+    """A formatted alert to send to users."""
+    title: str
+    body: str
+    severity: str           # "info", "warning", "critical"
+    symbol: str
+    signal: str             # "BUY", "SELL", "HOLD"
+    confidence: float
+    data: Dict[str, Any] = field(default_factory=dict)
+
+    def to_markdown(self) -> str:
+        """Format as Markdown for Telegram."""
+        severity_emoji = {"info": "ℹ️", "warning": "⚠️", "critical": "🚨"}
+        signal_emoji = {"BUY": "🟢", "SELL": "🔴", "HOLD": "🟡"}
+        emoji = severity_emoji.get(self.severity, "📊")
+        sig = signal_emoji.get(self.signal, "⚪")
+
+        lines = [
+            f"{emoji} **{self.title}**",
+            f"",
+            f"**{self.symbol}** {sig} {self.signal} ({self.confidence:.0%})",
+            f"",
+            self.body,
+        ]
+        return "\n".join(lines)
+
+    def to_text(self) -> str:
+        """Format as plain text for email."""
+        return f"[{self.severity.upper()}] {self.title}\n{self.symbol} → {self.signal} ({self.confidence:.0%})\n\n{self.body}"
+
+
+class AlertChannel(ABC):
+    """Base class for all alert channels."""
+
+    @abstractmethod
+    def send(self, message: AlertMessage) -> bool:
+        """Send an alert. Returns True if successful."""
+        ...
+
+    @abstractmethod
+    def is_configured(self) -> bool:
+        """Check if this channel has required credentials."""
+        ...
+
+
+class TelegramChannel(AlertChannel):
+    """Telegram Bot alert channel.
+
+    Configure via:
+        TELEGRAM_BOT_TOKEN  — Bot token from @BotFather
+        TELEGRAM_CHAT_ID    — Chat ID (user or group)
+    """
+
+    def __init__(
+        self,
+        bot_token: Optional[str] = None,
+        chat_id: Optional[str] = None,
+    ):
+        self.bot_token = bot_token or os.environ.get("TELEGRAM_BOT_TOKEN", "")
+        self.chat_id = chat_id or os.environ.get("TELEGRAM_CHAT_ID", "")
+
+    def is_configured(self) -> bool:
+        return bool(self.bot_token and self.chat_id)
+
+    def send(self, message: AlertMessage) -> bool:
+        if not self.is_configured():
+            logger.debug("Telegram not configured — skipping alert")
+            return False
+
+        text = message.to_markdown()
+        url = f"https://api.telegram.org/bot{self.bot_token}/sendMessage"
+        payload = json.dumps({
+            "chat_id": self.chat_id,
+            "text": text,
+            "parse_mode": "Markdown",
+            "disable_web_page_preview": True,
+        }).encode("utf-8")
+
+        try:
+            req = urllib.request.Request(
+                url, data=payload,
+                headers={"Content-Type": "application/json"},
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                result = json.loads(resp.read().decode())
+                if result.get("ok"):
+                    logger.info("Telegram alert sent: %s", message.title)
+                    return True
+                else:
+                    logger.warning("Telegram API error: %s", result.get("description"))
+                    return False
+        except Exception as exc:
+            logger.warning("Telegram send failed: %s", exc)
+            return False
+
+
+class EmailChannel(AlertChannel):
+    """Email (SMTP) alert channel.
+
+    Configure via:
+        SMTP_HOST     — SMTP server (e.g., smtp.gmail.com)
+        SMTP_PORT     — SMTP port (default 587)
+        SMTP_USER     — Email address
+        SMTP_PASSWORD — App password (not regular password)
+        EMAIL_TO      — Recipient email(s), comma-separated
+    """
+
+    def __init__(
+        self,
+        smtp_host: Optional[str] = None,
+        smtp_port: Optional[int] = None,
+        smtp_user: Optional[str] = None,
+        smtp_password: Optional[str] = None,
+        email_to: Optional[str] = None,
+    ):
+        self.smtp_host = smtp_host or os.environ.get("SMTP_HOST", "smtp.gmail.com")
+        self.smtp_port = smtp_port or int(os.environ.get("SMTP_PORT", "587"))
+        self.smtp_user = smtp_user or os.environ.get("SMTP_USER", "")
+        self.smtp_password = smtp_password or os.environ.get("SMTP_PASSWORD", "")
+        self.email_to = email_to or os.environ.get("EMAIL_TO", "")
+
+    def is_configured(self) -> bool:
+        return bool(self.smtp_user and self.smtp_password and self.email_to)
+
+    def send(self, message: AlertMessage) -> bool:
+        if not self.is_configured():
+            logger.debug("Email not configured — skipping alert")
+            return False
+
+        recipients = [r.strip() for r in self.email_to.split(",") if r.strip()]
+
+        msg = MIMEMultipart("alternative")
+        msg["Subject"] = f"[AlphaForge] {message.signal} — {message.symbol}: {message.title}"
+        msg["From"] = self.smtp_user
+        msg["To"] = ", ".join(recipients)
+
+        # Plain text
+        msg.attach(MIMEText(message.to_text(), "plain"))
+
+        # HTML version
+        html = f"""
+        <html><body>
+        <h2>{message.title}</h2>
+        <p><strong>{message.symbol}</strong> → <strong>{message.signal}</strong> ({message.confidence:.0%})</p>
+        <p>{message.body.replace(chr(10), '<br>')}</p>
+        <hr><p><small>Sent by AlphaForge Alerting System</small></p>
+        </body></html>
+        """
+        msg.attach(MIMEText(html, "html"))
+
+        try:
+            context = ssl.create_default_context()
+            with smtplib.SMTP(self.smtp_host, self.smtp_port) as server:
+                server.starttls(context=context)
+                server.login(self.smtp_user, self.smtp_password)
+                server.sendmail(self.smtp_user, recipients, msg.as_string())
+            logger.info("Email alert sent to %s", recipients)
+            return True
+        except Exception as exc:
+            logger.warning("Email send failed: %s", exc)
+            return False
+
+
+class WebhookChannel(AlertChannel):
+    """Generic webhook (HTTP POST JSON) alert channel.
+
+    Configure via:
+        WEBHOOK_URL — Target URL
+        WEBHOOK_SECRET — Optional HMAC secret for signature verification
+    """
+
+    def __init__(
+        self,
+        webhook_url: Optional[str] = None,
+        secret: Optional[str] = None,
+    ):
+        self.webhook_url = webhook_url or os.environ.get("WEBHOOK_URL", "")
+        self.secret = secret or os.environ.get("WEBHOOK_SECRET", "")
+
+    def is_configured(self) -> bool:
+        return bool(self.webhook_url)
+
+    def send(self, message: AlertMessage) -> bool:
+        if not self.is_configured():
+            logger.debug("Webhook not configured — skipping alert")
+            return False
+
+        import hmac
+        import hashlib
+        import time
+
+        payload = {
+            "timestamp": int(time.time()),
+            "symbol": message.symbol,
+            "signal": message.signal,
+            "confidence": message.confidence,
+            "severity": message.severity,
+            "title": message.title,
+            "body": message.body,
+            "data": message.data,
+        }
+
+        body = json.dumps(payload).encode("utf-8")
+        headers = {"Content-Type": "application/json"}
+
+        # HMAC signature
+        if self.secret:
+            sig = hmac.new(self.secret.encode(), body, hashlib.sha256).hexdigest()
+            headers["X-AlphaForge-Signature"] = f"sha256={sig}"
+
+        try:
+            req = urllib.request.Request(
+                self.webhook_url, data=body, headers=headers,
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                status = resp.status
+                logger.info("Webhook sent (HTTP %d)", status)
+                return 200 <= status < 300
+        except Exception as exc:
+            logger.warning("Webhook send failed: %s", exc)
+            return False

alphaforge/alerting/dispatcher.py

@@ -0,0 +1,152 @@
+"""Alert dispatcher — routes signals to configured channels.
+
+Monitors signal changes and triggers alerts when:
+- Consensus signal changes (BUY→SELL, HOLD→BUY, etc.)
+- Confidence crosses threshold (>0.7 strong signal)
+- Risk limits breached
+- Watchlist triggers
+"""
+from __future__ import annotations
+
+import logging
+import time
+from typing import Dict, List, Optional
+
+from alphaforge.alerting.channels import (
+    AlertChannel,
+    AlertMessage,
+    EmailChannel,
+    TelegramChannel,
+    WebhookChannel,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class AlertDispatcher:
+    """Route alert messages to all configured channels.
+
+    Usage:
+        dispatcher = AlertDispatcher()
+        dispatcher.add_channel(TelegramChannel())
+        dispatcher.add_channel(EmailChannel())
+
+        # On signal change
+        dispatcher.dispatch(AlertMessage(
+            title="Signal Change: INFY.NS",
+            body="Consensus shifted from HOLD to BUY (confidence: 72%)",
+            severity="info",
+            symbol="INFY.NS",
+            signal="BUY",
+            confidence=0.72,
+        ))
+    """
+
+    def __init__(self, channels: Optional[List[AlertChannel]] = None):
+        self.channels: List[AlertChannel] = channels or []
+        self._signal_history: Dict[str, str] = {}  # ticker → last signal
+        self._alert_history: List[float] = []  # timestamps of sent alerts
+        self._min_interval = 300  # 5 min between alerts for same ticker
+
+    def add_channel(self, channel: AlertChannel):
+        """Add an alert channel (Telegram, Email, Webhook)."""
+        if channel.is_configured():
+            self.channels.append(channel)
+            logger.info("Added alert channel: %s", type(channel).__name__)
+        else:
+            logger.debug("Skipped unconfigured channel: %s", type(channel).__name__)
+
+    @classmethod
+    def from_env(cls) -> "AlertDispatcher":
+        """Create dispatcher with all configured channels from environment."""
+        dispatcher = cls()
+        dispatcher.add_channel(TelegramChannel())
+        dispatcher.add_channel(EmailChannel())
+        dispatcher.add_channel(WebhookChannel())
+        return dispatcher
+
+    def dispatch(self, message: AlertMessage) -> Dict[str, bool]:
+        """Send message to all configured channels. Returns {channel: success}."""
+        results = {}
+        for channel in self.channels:
+            try:
+                ok = channel.send(message)
+                results[type(channel).__name__] = ok
+            except Exception as exc:
+                logger.warning("Channel %s failed: %s", type(channel).__name__, exc)
+                results[type(channel).__name__] = False
+        return results
+
+    def check_signal_change(
+        self,
+        ticker: str,
+        new_signal: str,
+        confidence: float,
+        consensus_summary: str = "",
+    ) -> Optional[AlertMessage]:
+        """Check if signal changed and generate alert if so.
+
+        Returns AlertMessage if signal changed, None otherwise.
+        """
+        old_signal = self._signal_history.get(ticker)
+        self._signal_history[ticker] = new_signal
+
+        # Rate limit
+        now = time.time()
+        recent_alerts = [t for t in self._alert_history if now - t < self._min_interval]
+        if len(recent_alerts) >= 5:  # Max 5 alerts per 5 minutes
+            return None
+
+        # Determine if we should alert
+        should_alert = False
+        severity = "info"
+
+        if old_signal is None:
+            # First analysis — only alert for strong signals
+            if confidence > 0.7 and new_signal != "HOLD":
+                should_alert = True
+                severity = "info"
+        elif old_signal != new_signal:
+            # Signal change
+            should_alert = True
+            severity = "warning" if new_signal in ("BUY", "SELL") else "info"
+            if confidence > 0.8:
+                severity = "critical"
+        elif confidence > 0.8 and new_signal != "HOLD":
+            # High confidence — periodic reminder
+            if now - self._alert_history[-1] if self._alert_history else 0 > 3600:
+                should_alert = True
+                severity = "info"
+
+        if not should_alert:
+            return None
+
+        self._alert_history.append(now)
+
+        body = f"Signal changed: {old_signal or 'N/A'} → {new_signal}"
+        if consensus_summary:
+            body += f"\n{consensus_summary}"
+        body += f"\nConfidence: {confidence:.0%}"
+
+        return AlertMessage(
+            title=f"Signal {'Change' if old_signal else 'Alert'}: {ticker}",
+            body=body,
+            severity=severity,
+            symbol=ticker,
+            signal=new_signal,
+            confidence=confidence,
+            data={"old_signal": old_signal, "ticker": ticker},
+        )
+
+    def dispatch_signal_change(
+        self,
+        ticker: str,
+        new_signal: str,
+        confidence: float,
+        consensus_summary: str = "",
+    ) -> Dict[str, bool]:
+        """Check and dispatch signal change alert in one call."""
+        msg = self.check_signal_change(ticker, new_signal, confidence, consensus_summary)
+        if msg:
+            return self.dispatch(msg)
+        return {}

alphaforge/alerts/__init__.py

@@ -0,0 +1 @@
+"""Alert engine and notifier for stock monitoring."""

alphaforge/alerts/engine.py

@@ -0,0 +1,185 @@
+"""Enhanced alert engine — volume, consensus, pattern, gap, and technical alerts."""
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field, asdict
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+import pandas as pd
+
+from alphaforge.analysis.consensus import ConsensusResult
+from alphaforge.models.algorithms.base import AlgorithmResult
+
+
+@dataclass
+class StockAlert:
+    """A single alert event."""
+    ticker: str
+    alert_type: str  # VOLUME_SPIKE, CONSENSUS, PATTERN, GAP, RSI_EXTREME, SQUEEZE
+    severity: str  # CRITICAL, HIGH, MEDIUM, LOW
+    message: str
+    timestamp: str = field(default_factory=lambda: datetime.utcnow().isoformat())
+    signal: Optional[str] = None
+    confidence: Optional[float] = None
+
+
+class AlertEngine:
+    """Generate alerts from technical analysis, consensus, and price action."""
+
+    def evaluate(
+        self,
+        ticker: str,
+        df: pd.DataFrame,
+        algo_results: List[AlgorithmResult],
+        consensus: ConsensusResult,
+    ) -> List[StockAlert]:
+        """Evaluate all alert conditions and return triggered alerts."""
+        alerts = []
+        alerts.extend(self._volume_spike(ticker, df))
+        alerts.extend(self._gap_detection(ticker, df))
+        alerts.extend(self._rsi_extremes(ticker, df))
+        alerts.extend(self._bollinger_squeeze(ticker, df))
+        alerts.extend(self._consensus_alerts(ticker, consensus))
+        alerts.extend(self._divergence_alerts(ticker, algo_results))
+        alerts.extend(self._pattern_alerts(ticker, df))
+        return alerts
+
+    def _volume_spike(self, ticker: str, df: pd.DataFrame) -> List[StockAlert]:
+        alerts = []
+        if "Volume" not in df.columns or len(df) < 20:
+            return alerts
+        vol = df["Volume"]
+        avg_vol = vol.rolling(20).mean().iloc[-1]
+        if pd.isna(avg_vol) or avg_vol == 0:
+            return alerts
+        current_vol = vol.iloc[-1]
+        ratio = current_vol / avg_vol
+        if ratio > 3.0:
+            alerts.append(StockAlert(
+                ticker=ticker,
+                alert_type="VOLUME_SPIKE",
+                severity="HIGH",
+                message=f"Volume {ratio:.1f}x average — {current_vol:,.0f} vs avg {avg_vol:,.0f}",
+                signal="BUY" if df["Close"].iloc[-1] > df["Close"].iloc[-2] else "SELL",
+            ))
+        elif ratio > 2.0:
+            alerts.append(StockAlert(
+                ticker=ticker,
+                alert_type="VOLUME_SPIKE",
+                severity="MEDIUM",
+                message=f"Volume {ratio:.1f}x average",
+            ))
+        return alerts
+
+    def _gap_detection(self, ticker: str, df: pd.DataFrame) -> List[StockAlert]:
+        alerts = []
+        if len(df) < 2:
+            return alerts
+        prev_close = df["Close"].iloc[-2]
+        if pd.isna(prev_close) or prev_close <= 0:
+            return alerts
+        gap_pct = (df["Open"].iloc[-1] - prev_close) / prev_close
+        if not pd.isna(gap_pct) and abs(gap_pct) > 0.03:
+            direction = "up" if gap_pct > 0 else "down"
+            severity = "CRITICAL" if abs(gap_pct) > 0.05 else "HIGH"
+            alerts.append(StockAlert(
+                ticker=ticker,
+                alert_type="GAP",
+                severity=severity,
+                message=f"Gap {direction} {abs(gap_pct)*100:.1f}%",
+                signal="BUY" if gap_pct > 0 else "SELL",
+            ))
+        return alerts
+
+    def _rsi_extremes(self, ticker: str, df: pd.DataFrame) -> List[StockAlert]:
+        alerts = []
+        if "RSI_14" not in df.columns:
+            return alerts
+        rsi = df["RSI_14"].iloc[-1]
+        if pd.isna(rsi):
+            return alerts
+        if rsi < 20:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="RSI_EXTREME", severity="CRITICAL",
+                message=f"RSI extremely oversold ({rsi:.1f})", signal="BUY",
+            ))
+        elif rsi < 30:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="RSI_EXTREME", severity="HIGH",
+                message=f"RSI oversold ({rsi:.1f})", signal="BUY",
+            ))
+        elif rsi > 80:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="RSI_EXTREME", severity="CRITICAL",
+                message=f"RSI extremely overbought ({rsi:.1f})", signal="SELL",
+            ))
+        elif rsi > 70:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="RSI_EXTREME", severity="HIGH",
+                message=f"RSI overbought ({rsi:.1f})", signal="SELL",
+            ))
+        return alerts
+
+    def _bollinger_squeeze(self, ticker: str, df: pd.DataFrame) -> List[StockAlert]:
+        alerts = []
+        if "SQUEEZE" not in df.columns:
+            return alerts
+        if df["SQUEEZE"].iloc[-1]:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="SQUEEZE", severity="MEDIUM",
+                message="Bollinger Squeeze detected — expect volatility expansion",
+            ))
+        return alerts
+
+    def _consensus_alerts(self, ticker: str, consensus: ConsensusResult) -> List[StockAlert]:
+        alerts = []
+        if consensus.buy_pct >= 0.75:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="CONSENSUS", severity="CRITICAL",
+                message=f"{consensus.buy_count}/{consensus.total_algorithms} algorithms agree on BUY ({consensus.buy_pct*100:.0f}%)",
+                signal="BUY", confidence=consensus.confidence,
+            ))
+        elif consensus.sell_pct >= 0.75:
+            alerts.append(StockAlert(
+                ticker=ticker, alert_type="CONSENSUS", severity="CRITICAL",
+                message=f"{consensus.sell_count}/{consensus.total_algorithms} algorithms agree on SELL ({consensus.sell_pct*100:.0f}%)",
+                signal="SELL", confidence=consensus.confidence,
+            ))
+        return alerts
+
+    def _divergence_alerts(self, ticker: str, results: List[AlgorithmResult]) -> List[StockAlert]:
+        alerts = []
+        for r in results:
+            if "divergence" in r.reason.lower() and r.confidence > 0.5:
+                alerts.append(StockAlert(
+                    ticker=ticker, alert_type="DIVERGENCE", severity="HIGH",
+                    message=f"{r.algorithm_name}: {r.reason}",
+                    signal=r.signal, confidence=r.confidence,
+                ))
+        return alerts
+
+    def _pattern_alerts(self, ticker: str, df: pd.DataFrame) -> List[StockAlert]:
+        alerts = []
+        if len(df) < 3:
+            return alerts
+        # Check for strong candlestick patterns
+        recent = df.iloc[-3:]
+        o, h, l, c = recent["Open"], recent["High"], recent["Low"], recent["Close"]
+
+        # Three White Soldiers
+        if all(c.iloc[-i] > o.iloc[-i] for i in range(1, 4)):
+            if all(c.iloc[-i] > c.iloc[-i-1] for i in range(1, 3)):
+                alerts.append(StockAlert(
+                    ticker=ticker, alert_type="PATTERN", severity="HIGH",
+                    message="Three White Soldiers pattern detected", signal="BUY",
+                ))
+        # Three Black Crows
+        if all(c.iloc[-i] < o.iloc[-i] for i in range(1, 4)):
+            if all(c.iloc[-i] < c.iloc[-i-1] for i in range(1, 3)):
+                alerts.append(StockAlert(
+                    ticker=ticker, alert_type="PATTERN", severity="HIGH",
+                    message="Three Black Crows pattern detected", signal="SELL",
+                ))
+        return alerts

alphaforge/alerts/notifier.py

@@ -0,0 +1,69 @@
+"""Alert persistence and notification."""
+from __future__ import annotations
+
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import List, Optional
+
+from alphaforge.alerts.engine import StockAlert
+
+# Windows console can't render emoji, use text fallback
+_WINDOWS = sys.platform == "win32"
+_SEVERITY_ICON = {
+    "CRITICAL": "[!!!]",
+    "HIGH": "[!!]",
+    "MEDIUM": "[!]",
+    "LOW": "[+]",
+} if _WINDOWS else {
+    "CRITICAL": "\U0001f534",
+    "HIGH": "\U0001f7e0",
+    "MEDIUM": "\U0001f7e1",
+    "LOW": "\U0001f7e2",
+}
+_SIGNAL_ICON = {
+    "BUY": "UP" if _WINDOWS else "\U0001f4c8",
+    "SELL": "DOWN" if _WINDOWS else "\U0001f4c9",
+} if _WINDOWS else {
+    "BUY": "\U0001f4c8",
+    "SELL": "\U0001f4c9",
+}
+
+
+class AlertNotifier:
+    """Persist and display alerts."""
+
+    def __init__(self, output_dir: Optional[Path] = None):
+        self.output_dir = output_dir or Path("data/alerts")
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+
+    def save_alerts(self, alerts: List[StockAlert]) -> Path:
+        """Save alerts to JSON file."""
+        if not alerts:
+            return self.output_dir / "no_alerts.json"
+
+        timestamp = datetime.utcnow().strftime("%Y%m%d_%H%M%S")
+        filepath = self.output_dir / f"alerts_{timestamp}.json"
+
+        data = [vars(a) for a in alerts]
+        with open(filepath, "w") as f:
+            json.dump(data, f, indent=2)
+
+        return filepath
+
+    def format_summary(self, alerts: List[StockAlert]) -> str:
+        """Format alerts into a readable summary."""
+        if not alerts:
+            return "No alerts triggered."
+
+        lines = ["=== ALERT SUMMARY ===\n"]
+        severity_order = {"CRITICAL": 0, "HIGH": 1, "MEDIUM": 2, "LOW": 3}
+        sorted_alerts = sorted(alerts, key=lambda a: severity_order.get(a.severity, 4))
+
+        for alert in sorted_alerts:
+            icon = _SEVERITY_ICON.get(alert.severity, "[-]")
+            sig = _SIGNAL_ICON.get(alert.signal, "")
+            lines.append(f"{icon} [{alert.ticker}] {alert.alert_type}: {alert.message} {sig}")
+
+        return "\n".join(lines)

alphaforge/analysis/__init__.py

@@ -0,0 +1 @@
+"""Analysis engine — stock analysis, consensus, and universe scanning."""