358 lines
14 KiB
Python
358 lines
14 KiB
Python
|
"""
|
||
|
|
Tests for MALKHUT Strategy DSL.
|
||
|
|
|
||
|
|
Verifies:
|
||
|
|
- DSL parsing (text → StrategyTemplate)
|
||
|
|
- DSL decompilation (StrategyTemplate → text)
|
||
|
|
- Action primitives (QUOTE, CROSS, EXIT, etc.)
|
||
|
|
- Market sensors (read values from state)
|
||
|
|
- Decision rules (conditional logic)
|
||
|
|
- Strategy selection (highest priority match)
|
||
|
|
- Builtin strategies
|
||
|
|
- Edge cases (empty strategy, unknown sensor, unknown action)
|
||
|
|
"""
|
||
|
|
import pytest
|
||
|
|
from malkhut.state import (
|
||
|
|
AccountState, FulfilmentPolicyParams, MarketWorldState, Mode,
|
||
|
|
OrderBookState, PositionState, PriceLevel, Side, TradePathState,
|
||
|
|
VenueRules,
|
||
|
|
)
|
||
|
|
from malkhut.actions import ActionKind, FulfilmentAction
|
||
|
|
from malkhut.training.dsl import (
|
||
|
|
ActionType, ActionPrimitive, SensorType, ComparisonOp,
|
||
|
|
SensorCondition, DecisionRule, StrategyTemplate,
|
||
|
|
StrategyDSLParser, StrategyDSLCompiler, DSLParseError,
|
||
|
|
BUILTIN_STRATEGIES, get_builtin_strategy, list_builtin_strategies,
|
||
|
|
_read_sensor, _primitive_to_action,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
def _venue():
|
||
|
|
return VenueRules(
|
||
|
|
exchange="bingx", symbol="BTCUSDT", tick_size=0.1, lot_size=0.001,
|
||
|
|
min_qty=0.001, min_notional=5.0, maker_fee_bps=-0.2, taker_fee_bps=0.5,
|
||
|
|
post_only_supported=True, reduce_only_supported=True,
|
||
|
|
max_orders_per_second=100, max_cancels_per_minute=120,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
def _state(bid=50000.0, ask=50001.0, equity=10000.0, **kw):
|
||
|
|
path = kw.get("trade_path")
|
||
|
|
return MarketWorldState(
|
||
|
|
ts_ns=kw.get("ts", 1_000_000_000), mode=Mode.REPLAY_NO_IMPACT,
|
||
|
|
venue=_venue(),
|
||
|
|
book=OrderBookState(
|
||
|
|
ts_ns=1_000_000_000, symbol="BTCUSDT",
|
||
|
|
bids=(PriceLevel(bid, 1.0),), asks=(PriceLevel(ask, 1.0),),
|
||
|
|
),
|
||
|
|
account=AccountState(
|
||
|
|
ts_ns=1_000_000_000, equity=equity, wallet_balance=equity,
|
||
|
|
available_balance=equity, margin_used=0.0, total_notional=0.0,
|
||
|
|
positions=kw.get("positions", {}),
|
||
|
|
),
|
||
|
|
trade_path=path,
|
||
|
|
)
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 1. SENSOR CONDITIONS
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestSensorConditions:
|
||
|
|
def test_spread_bps(self):
|
||
|
|
s = _state(bid=50000.0, ask=50001.0)
|
||
|
|
cond = SensorCondition(SensorType.SPREAD_BPS, ComparisonOp.LT, 5.0)
|
||
|
|
assert cond.evaluate(s)
|
||
|
|
|
||
|
|
def test_spread_bps_fails(self):
|
||
|
|
s = _state(bid=50000.0, ask=51000.0) # 1000pt spread = ~2000bps
|
||
|
|
cond = SensorCondition(SensorType.SPREAD_BPS, ComparisonOp.LT, 5.0)
|
||
|
|
assert not cond.evaluate(s) # 2000bps > 5bps → False
|
||
|
|
|
||
|
|
def test_toxicity(self):
|
||
|
|
from malkhut.state import TradePathState
|
||
|
|
tp = TradePathState(
|
||
|
|
symbol="BTCUSDT", side=Side.BUY, entry_ts_ns=0, now_ts_ns=100_000_000,
|
||
|
|
bars_held=5, seconds_held=50.0, pnl_bps=0.0, mae_bps=-10.0,
|
||
|
|
mfe_bps=15.0, distance_from_mfe_bps=15.0, distance_from_entry_bps=0.0,
|
||
|
|
time_to_mfe_s=20.0, time_in_loss_s=50.0, time_in_profit_s=50.0,
|
||
|
|
time_since_last_profit_s=10.0, time_since_deep_mae_s=10.0,
|
||
|
|
loss_to_profit_transitions=1, deep_loss_recoveries=0,
|
||
|
|
failed_recovery_count=0, recovery_velocity_bps_per_s=1.0,
|
||
|
|
adverse_velocity_bps_per_s=-0.5,
|
||
|
|
dolphin_regime_score=0.5, jericho_signal_strength=0.3,
|
||
|
|
volatility_bps=15.0, orderflow_toxicity=0.8,
|
||
|
|
queue_churn_score=0.2, book_imbalance=0.1, cross_venue_lead_score=0.1,
|
||
|
|
)
|
||
|
|
s = _state(trade_path=tp)
|
||
|
|
cond = SensorCondition(SensorType.TOXICITY, ComparisonOp.GT, 0.5)
|
||
|
|
assert cond.evaluate(s)
|
||
|
|
|
||
|
|
def test_position_qty(self):
|
||
|
|
pos = PositionState(
|
||
|
|
symbol="BTCUSDT", qty=0.1, avg_entry=50000.0,
|
||
|
|
unrealized_pnl=0.0, realized_pnl=0.0,
|
||
|
|
liquidation_price=None, leverage=0.5, side=Side.BUY,
|
||
|
|
)
|
||
|
|
s = _state(positions={"BTCUSDT": pos})
|
||
|
|
cond = SensorCondition(SensorType.POSITION_QTY, ComparisonOp.GT, 0.05)
|
||
|
|
assert cond.evaluate(s)
|
||
|
|
|
||
|
|
def test_equity(self):
|
||
|
|
s = _state(equity=10000.0)
|
||
|
|
cond = SensorCondition(SensorType.EQUITY, ComparisonOp.GT, 5000.0)
|
||
|
|
assert cond.evaluate(s)
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 2. SENSOR READING
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestSensorReading:
|
||
|
|
def test_read_spread_bps(self):
|
||
|
|
s = _state(bid=50000.0, ask=50001.0)
|
||
|
|
val = _read_sensor(SensorType.SPREAD_BPS, s)
|
||
|
|
assert val > 0
|
||
|
|
|
||
|
|
def test_read_equity(self):
|
||
|
|
s = _state(equity=10000.0)
|
||
|
|
val = _read_sensor(SensorType.EQUITY, s)
|
||
|
|
assert val == 10000.0
|
||
|
|
|
||
|
|
def test_read_imbalance(self):
|
||
|
|
s = _state()
|
||
|
|
val = _read_sensor(SensorType.IMBALANCE, s)
|
||
|
|
assert isinstance(val, float)
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 3. DSL PARSER
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestDSLParser:
|
||
|
|
def test_parse_simple_strategy(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
assert template.name == "test"
|
||
|
|
assert template.rule_count == 2
|
||
|
|
|
||
|
|
def test_parse_multiple_conditions(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "multi" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 AND orderflow_toxicity < 0.3 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
assert template.rule_count == 1
|
||
|
|
assert len(template.rules[0].conditions) == 2
|
||
|
|
|
||
|
|
def test_parse_bare_action(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "bare" {
|
||
|
|
PRIORITY 1: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
assert template.rule_count == 1
|
||
|
|
assert template.rules[0].action.action_type == ActionType.NOOP
|
||
|
|
|
||
|
|
def test_parse_exit(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "exit_strat" {
|
||
|
|
PRIORITY 1: IF time_in_trade > 300 THEN EXIT
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
assert template.rules[0].action.action_type == ActionType.EXIT
|
||
|
|
|
||
|
|
def test_parse_cross(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "cross_strat" {
|
||
|
|
PRIORITY 1: IF spread_bps < 2.0 THEN CROSS(BUY, 0.1)
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
action = template.rules[0].action
|
||
|
|
assert action.action_type == ActionType.CROSS
|
||
|
|
assert action.side == Side.BUY
|
||
|
|
|
||
|
|
def test_parse_missing_name(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
with pytest.raises(DSLParseError):
|
||
|
|
parser.parse("STRATEGY { PRIORITY 1: NOOP }")
|
||
|
|
|
||
|
|
def test_parse_missing_braces(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
with pytest.raises(DSLParseError):
|
||
|
|
parser.parse('STRATEGY "test" PRIORITY 1: NOOP')
|
||
|
|
|
||
|
|
def test_parse_empty_rules(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
with pytest.raises(DSLParseError):
|
||
|
|
parser.parse('STRATEGY "test" {}')
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 4. STRATEGY TEMPLATE
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestStrategyTemplate:
|
||
|
|
def test_select_action_matches_rule(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
s = _state(bid=50000.0, ask=50001.0) # 1pt spread = 0.2bps
|
||
|
|
action = template.select_action(s)
|
||
|
|
# 0.2bps < 5.0bps → QUOTE matches
|
||
|
|
assert action.kind == ActionKind.PLACE
|
||
|
|
|
||
|
|
def test_select_action_noop_when_no_match(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 0.01 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
s = _state()
|
||
|
|
action = template.select_action(s)
|
||
|
|
assert action.kind == ActionKind.NOOP
|
||
|
|
|
||
|
|
def test_rule_count(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: IF time_in_trade > 300 THEN EXIT
|
||
|
|
PRIORITY 3: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
assert template.rule_count == 3
|
||
|
|
|
||
|
|
def test_action_types_used(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: IF time_in_trade > 300 THEN EXIT
|
||
|
|
PRIORITY 3: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
types = template.action_types_used
|
||
|
|
assert ActionType.QUOTE in types
|
||
|
|
assert ActionType.EXIT in types
|
||
|
|
assert ActionType.NOOP in types
|
||
|
|
|
||
|
|
def test_sensors_used(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 AND orderflow_toxicity > 0.5 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
sensors = template.sensors_used
|
||
|
|
assert SensorType.SPREAD_BPS in sensors
|
||
|
|
assert SensorType.TOXICITY in sensors
|
||
|
|
|
||
|
|
def test_evaluate_conditions(self):
|
||
|
|
parser = StrategyDSLParser()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "test" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = parser.parse(dsl)
|
||
|
|
s = _state()
|
||
|
|
results = template.evaluate_conditions(s)
|
||
|
|
assert len(results) == 2
|
||
|
|
assert results[0][0] == 1 # priority
|
||
|
|
assert isinstance(results[0][1], bool) # matched
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 5. DSL COMPILER (roundtrip)
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestDSLCompiler:
|
||
|
|
def test_compile_and_decompile(self):
|
||
|
|
compiler = StrategyDSLCompiler()
|
||
|
|
dsl = '''
|
||
|
|
STRATEGY "roundtrip" {
|
||
|
|
PRIORITY 1: IF spread_bps < 5.0 THEN QUOTE(BUY, 0, 0.25)
|
||
|
|
PRIORITY 2: NOOP
|
||
|
|
}
|
||
|
|
'''
|
||
|
|
template = compiler.compile(dsl)
|
||
|
|
output = compiler.decompile(template)
|
||
|
|
assert "roundtrip" in output
|
||
|
|
assert "QUOTE" in output
|
||
|
|
assert "NOOP" in output
|
||
|
|
|
||
|
|
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
# 6. BUILTIN STRATEGIES
|
||
|
|
# ══════════════════════════════════════════════════════════════════════════════
|
||
|
|
|
||
|
|
class TestBuiltinStrategies:
|
||
|
|
def test_list_builtins(self):
|
||
|
|
names = list_builtin_strategies()
|
||
|
|
assert "passive_maker" in names
|
||
|
|
assert "aggressive_taker" in names
|
||
|
|
assert "toxicity_avoider" in names
|
||
|
|
assert "path_risk_exit" in names
|
||
|
|
assert "regime_adaptive" in names
|
||
|
|
|
||
|
|
def test_get_builtin(self):
|
||
|
|
text = get_builtin_strategy("passive_maker")
|
||
|
|
assert text is not None
|
||
|
|
assert "STRATEGY" in text
|
||
|
|
|
||
|
|
def test_parse_all_builtins(self):
|
||
|
|
compiler = StrategyDSLCompiler()
|
||
|
|
for name in list_builtin_strategies():
|
||
|
|
text = get_builtin_strategy(name)
|
||
|
|
template = compiler.compile(text)
|
||
|
|
assert template.name == name
|
||
|
|
assert template.rule_count > 0
|
||
|
|
|
||
|
|
def test_builtin_passive_maker_parsed(self):
|
||
|
|
compiler = StrategyDSLCompiler()
|
||
|
|
text = get_builtin_strategy("passive_maker")
|
||
|
|
template = compiler.compile(text)
|
||
|
|
assert template.rule_count >= 4
|
||
|
|
assert SensorType.SPREAD_BPS in template.sensors_used
|
||
|
|
assert SensorType.TOXICITY in template.sensors_used
|
||
|
|
|
||
|
|
def test_builtin_aggressive_taker_parsed(self):
|
||
|
|
compiler = StrategyDSLCompiler()
|
||
|
|
text = get_builtin_strategy("aggressive_taker")
|
||
|
|
template = compiler.compile(text)
|
||
|
|
assert ActionType.CROSS in template.action_types_used
|
||
|
|
|
||
|
|
def test_builtin_path_risk_exit_parsed(self):
|
||
|
|
compiler = StrategyDSLCompiler()
|
||
|
|
text = get_builtin_strategy("path_risk_exit")
|
||
|
|
template = compiler.compile(text)
|
||
|
|
assert SensorType.MAE_BPS in template.sensors_used
|
||
|
|
assert ActionType.EXIT in template.action_types_used
|