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