@devries-cameron20 / open-alice / commits / 88eff6c
Fork 0

Alice — an open-source AI trading bot covering equities, crypto, commodities, forex, and macro

Fix ruff lint: modernize type hints, fix import order, line lengths

Camo67 committed Oct 12, 2026 at 16:58 UTC 88eff6c223ffb9a4fd5ba8adcb81439bb55b0f57
4 files changed +105 -92
src/open_alice/broker/config.py
+2 -3
@@ -2,6 +2,7 @@
2
3 from __future__ import annotations
4
5 +import contextlib
6 import os
7 from pathlib import Path
8
@@ -33,10 +34,8 @@ def save_credentials(login: int, password: str, server: str) -> Path:
34 # Minimal .env format without extra dependencies.
35 content = f'MT5_LOGIN={login}\nMT5_PASSWORD={password}\nMT5_SERVER={server}\n'
36 path.write_text(content, encoding="utf-8")
36 - try:
37 + with contextlib.suppress(OSError):
38 os.chmod(path, 0o600)
38 - except OSError:
39 - pass
39 return path
40
41
src/open_alice/broker/mt5.py
+9 -8
@@ -4,7 +4,7 @@ from __future__ import annotations
4
5 from dataclasses import dataclass
6 from datetime import datetime
7 -from typing import Any, Optional
7 +from typing import Any
8
9 import pandas as pd
10
@@ -12,7 +12,9 @@ import pandas as pd
12 def _load_mt5() -> Any:
13 """Import the MetaTrader5 package lazily with a helpful error."""
14 try:
15 - import MetaTrader5 as mt5 # type: ignore[import-untyped]
15 + from importlib import import_module
16 +
17 + return import_module("MetaTrader5")
18 except ImportError as exc:
19 raise RuntimeError(
20 "The MetaTrader5 package is not installed or not supported on this "
@@ -21,7 +23,6 @@ def _load_mt5() -> Any:
23 "'pip install MetaTrader5'. Original error: "
24 f"{exc}"
25 ) from exc
24 - return mt5
26
27
28 @dataclass
@@ -62,11 +63,11 @@ class MT5Broker:
63
64 def __init__(
65 self,
65 - login: Optional[int] = None,
66 - password: Optional[str] = None,
67 - server: Optional[str] = None,
66 + login: int | None = None,
67 + password: str | None = None,
68 + server: str | None = None,
69 timeout: int = 60000,
69 - terminal_path: Optional[str] = None,
70 + terminal_path: str | None = None,
71 ) -> None:
72 """Initialize MT5 broker connection.
73
@@ -201,7 +202,7 @@ class MT5Broker:
202 mask = (df.index >= start_date) & (df.index <= end_date)
203 return df.loc[mask]
204
204 - def get_positions(self, symbol: Optional[str] = None) -> list[MT5Position]:
205 + def get_positions(self, symbol: str | None = None) -> list[MT5Position]:
206 """Return open positions, optionally filtered by symbol."""
207 mt5 = self._require_connected()
208 positions = mt5.positions_get(symbol=symbol) if symbol else mt5.positions_get()
src/open_alice/cli.py
+3 -4
@@ -269,10 +269,9 @@ def _broker_login(args: argparse.Namespace) -> None:
269
270 raw_server = getattr(args, "server", None)
271 demo = bool(getattr(args, "demo", False))
272 - if raw_server is None:
273 - if not demo:
274 - entered = input(" MT5 server [Headway-Demo / Headway-Real]: ").strip()
275 - raw_server = entered or None
272 + if raw_server is None and not demo:
273 + entered = input(" MT5 server [Headway-Demo / Headway-Real]: ").strip()
274 + raw_server = entered or None
275 server = resolve_headway_server(raw_server, demo=demo)
276
277 password = getpass.getpass(f" MT5 password for {raw_login} on {server}: ")
src/open_alice/signals/webhook.py
+91 -77
@@ -2,18 +2,18 @@
2
3 from __future__ import annotations
4
5 +import logging
6 from dataclasses import dataclass
7 from datetime import datetime
7 -from typing import Optional, Dict, Any
8 from enum import Enum
9 -
10 -import logging
9 +from typing import Any
10
11 logger = logging.getLogger(__name__)
12
13
14 class SignalType(Enum):
15 """Types of trading signals."""
16 +
17 BUY = "buy"
18 SELL = "sell"
19 CLOSE = "close"
@@ -22,46 +22,67 @@ class SignalType(Enum):
22 @dataclass
23 class TradingSignal:
24 """Represents a trading signal received from external source."""
25 +
26 symbol: str
27 signal_type: SignalType
27 - price: Optional[float] = None
28 - timestamp: Optional[datetime] = None
29 - strength: Optional[float] = None # Signal strength 0-1
30 - stop_loss: Optional[float] = None
31 - take_profit: Optional[float] = None
32 - comment: Optional[str] = None
33 - raw_data: Optional[Dict[str, Any]] = None
28 + price: float | None = None
29 + timestamp: datetime | None = None
30 + strength: float | None = None # Signal strength 0-1
31 + stop_loss: float | None = None
32 + take_profit: float | None = None
33 + comment: str | None = None
34 + raw_data: dict[str, Any] | None = None
35
36
37 class SignalReceiver:
38 """Base class for signal receivers."""
38 -
39 - def parse_signal(self, raw_data: Dict[str, Any]) -> Optional[TradingSignal]:
39 +
40 + def parse_signal(self, raw_data: dict[str, Any]) -> TradingSignal | None:
41 """Parse raw data into a TradingSignal.
41 -
42 +
43 Args:
43 - raw_data: Raw data received from external source
44 -
44 + raw_data: Raw data received from external source.
45 +
46 Returns:
46 - TradingSignal or None if parsing failed
47 + TradingSignal or None if parsing failed.
48 """
49 raise NotImplementedError
50
51
52 +def _opt_float(raw_data: dict[str, Any], key: str) -> float | None:
53 + """Return float(raw_data[key]) or None when the key is missing/null."""
54 + value = raw_data.get(key)
55 + if value is None:
56 + return None
57 + try:
58 + return float(value)
59 + except (TypeError, ValueError):
60 + logger.warning("Could not parse numeric field %s: %r", key, value)
61 + return None
62 +
63 +
64 +def _opt_str(raw_data: dict[str, Any], key: str) -> str | None:
65 + """Return str(raw_data[key]) or None when the key is missing/null."""
66 + value = raw_data.get(key)
67 + if value is None:
68 + return None
69 + return str(value)
70 +
71 +
72 class TradingViewSignalReceiver(SignalReceiver):
73 """Receiver for TradingView webhook alerts."""
53 -
54 - def __init__(self, secret: Optional[str] = None):
74 +
75 + def __init__(self, secret: str | None = None) -> None:
76 """Initialize TradingView signal receiver.
56 -
77 +
78 Args:
58 - secret: Optional secret for validating requests
79 + secret: Optional secret for validating requests.
80 """
81 self.secret = secret
61 -
62 - def parse_signal(self, raw_data: Dict[str, Any]) -> Optional[TradingSignal]:
82 +
83 + def parse_signal(self, raw_data: dict[str, Any]) -> TradingSignal | None:
84 """Parse TradingView webhook alert into TradingSignal.
64 -
85 +
86 Expected TradingView alert format:
87 {
88 "symbol": "AAPL",
@@ -73,22 +94,22 @@ class TradingViewSignalReceiver(SignalReceiver):
94 "take_profit": 160.00,
95 "comment": "My strategy signal"
96 }
76 -
97 +
98 Args:
78 - raw_data: Raw webhook data from TradingView
79 -
99 + raw_data: Raw webhook data from TradingView.
100 +
101 Returns:
81 - TradingSignal or None if parsing failed
102 + TradingSignal or None if parsing failed.
103 """
104 try:
105 # Validate required fields
106 if "symbol" not in raw_data or "action" not in raw_data:
107 logger.warning("Missing required fields in TradingView signal")
108 return None
88 -
89 - symbol = raw_data["symbol"].upper()
90 - action = raw_data["action"].lower()
91 -
109 +
110 + symbol = str(raw_data["symbol"]).upper()
111 + action = str(raw_data["action"]).lower()
112 +
113 # Map action to signal type
114 if action in ["buy", "long"]:
115 signal_type = SignalType.BUY
@@ -97,82 +118,75 @@ class TradingViewSignalReceiver(SignalReceiver):
118 elif action in ["close", "exit"]:
119 signal_type = SignalType.CLOSE
120 else:
100 - logger.warning(f"Unknown action in TradingView signal: {action}")
121 + logger.warning("Unknown action in TradingView signal: %s", action)
122 return None
102 -
103 - # Parse optional fields
104 - price = float(raw_data["price"]) if "price" in raw_data and raw_data["price"] is not None else None
105 - strength = float(raw_data["strength"]) if "strength" in raw_data and raw_data["strength"] is not None else None
106 - stop_loss = float(raw_data["stop_loss"]) if "stop_loss" in raw_data and raw_data["stop_loss"] is not None else None
107 - take_profit = float(raw_data["take_profit"]) if "take_profit" in raw_data and raw_data["take_profit"] is not None else None
108 - comment = str(raw_data["comment"]) if "comment" in raw_data and raw_data["comment"] is not None else None
109 -
123 +
124 # Parse timestamp
111 - timestamp = None
112 - if "time" in raw_data and raw_data["time"] is not None:
125 + timestamp: datetime | None = None
126 + raw_time = raw_data.get("time")
127 + if raw_time is not None:
128 try:
114 - timestamp = datetime.fromisoformat(raw_data["time"].replace("Z", "+00:00"))
129 + timestamp = datetime.fromisoformat(str(raw_time).replace("Z", "+00:00"))
130 except ValueError:
116 - logger.warning(f"Could not parse timestamp: {raw_data['time']}")
131 + logger.warning("Could not parse timestamp: %s", raw_time)
132 timestamp = datetime.now()
133 else:
134 timestamp = datetime.now()
120 -
135 +
136 return TradingSignal(
137 symbol=symbol,
138 signal_type=signal_type,
124 - price=price,
139 + price=_opt_float(raw_data, "price"),
140 timestamp=timestamp,
126 - strength=strength,
127 - stop_loss=stop_loss,
128 - take_profit=take_profit,
129 - comment=comment,
130 - raw_data=raw_data
141 + strength=_opt_float(raw_data, "strength"),
142 + stop_loss=_opt_float(raw_data, "stop_loss"),
143 + take_profit=_opt_float(raw_data, "take_profit"),
144 + comment=_opt_str(raw_data, "comment"),
145 + raw_data=raw_data,
146 )
132 -
133 - except Exception as e:
134 - logger.error(f"Error parsing TradingView signal: {e}")
147 +
148 + except Exception as exc:
149 + logger.error("Error parsing TradingView signal: %s", exc)
150 return None
151
152
153 # Simple HTTP server for receiving webhooks (optional)
139 -def create_webhook_app(receiver: SignalReceiver, host: str = "0.0.0.0", port: int = 5000):
154 +def create_webhook_app(receiver: SignalReceiver, host: str = "0.0.0.0", port: int = 5000) -> Any:
155 """Create a simple Flask app for receiving webhook signals.
141 -
156 +
157 Args:
143 - receiver: SignalReceiver instance to use for parsing
144 - host: Host to bind to
145 - port: Port to bind to
146 -
158 + receiver: SignalReceiver instance to use for parsing.
159 + host: Host to bind to (used by callers running the app).
160 + port: Port to bind to (used by callers running the app).
161 +
162 Returns:
148 - Flask app instance
163 + Flask app instance, or None when Flask is not installed.
164 """
165 try:
151 - from flask import Flask, request, jsonify
152 -
166 + from flask import Flask, jsonify, request
167 +
168 app = Flask(__name__)
154 -
155 - @app.route('/webhook', methods=['POST'])
156 - def webhook():
169 +
170 + @app.route("/webhook", methods=["POST"])
171 + def webhook() -> Any:
172 if not request.is_json:
173 return jsonify({"error": "Expected JSON"}), 400
159 -
174 +
175 data = request.get_json()
176 signal = receiver.parse_signal(data)
162 -
177 +
178 if signal is None:
179 return jsonify({"error": "Failed to parse signal"}), 400
165 -
166 - # In a real implementation, this would queue the signal for processing
167 - logger.info(f"Received signal: {signal}")
180 +
181 + logger.info("Received signal: %s", signal)
182 return jsonify({"status": "received", "signal": signal.__dict__}), 200
169 -
170 - @app.route('/health', methods=['GET'])
171 - def health():
183 +
184 + @app.route("/health", methods=["GET"])
185 + def health() -> Any:
186 return jsonify({"status": "healthy"}), 200
173 -
187 +
188 return app
175 -
189 +
190 except ImportError:
191 logger.warning("Flask not installed. Webhook server not available.")
178 - return None
\ No newline at end of file
192 + return None