qs-strategy 0.4.2

Synchronous reusable configured strategy core
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use super::*;
use crate::{CompletedBar, CompletedBarUpdate, Literal, MaterialArgs, NamedValue, StateConfig};

#[test]
fn failed_boundary_does_not_commit_strict_average_state() {
    for key in [crate::MATERIAL_STRICT_SMA, crate::MATERIAL_STRICT_EMA] {
        let source = SourceId::new("clock").unwrap();
        let mut strategy = ConfiguredStrategy::compile(
            StrategyConfig {
                strategy_id: "rollback".into(),
                title: "Strict numeric rollback".into(),
                parameters: vec![],
                initial_state: "idle".into(),
                sources: vec![source.clone()],
                trade_slots: vec![],
                variables: vec![],
                materials: vec![MaterialConfig {
                    id: "average".into(),
                    key: key.into(),
                    inputs: vec![Expr::Input {
                        field: "sample".into(),
                        value_type: ValueType::optional(ScalarType::Price),
                    }],
                    params: MaterialArgs::new([
                        ("source", MaterialArg::Source(source.clone())),
                        ("period", MaterialArg::Integer(3)),
                    ]),
                }],
                states: vec![
                    StateConfig {
                        id: "idle".into(),
                        transitions: vec![TransitionConfig {
                            priority: 1,
                            target: "done".into(),
                            assignments: vec![],
                            decision: None,
                            actions: vec![],
                            notes: vec![],
                            when: Expr::Gt {
                                left: Box::new(Expr::Div {
                                    left: Box::new(Expr::Literal {
                                        value: Literal::Number(1.0),
                                    }),
                                    right: Box::new(Expr::Input {
                                        field: "divisor".into(),
                                        value_type: ValueType::required(ScalarType::Number),
                                    }),
                                }),
                                right: Box::new(Expr::Literal {
                                    value: Literal::Number(0.0),
                                }),
                            },
                        }],
                    },
                    StateConfig {
                        id: "done".into(),
                        transitions: vec![],
                    },
                ],
            },
            &MaterialLibrary::builtins(),
            "instance",
            "EURUSD",
        )
        .unwrap();
        let mut input = StrategyInput {
            time: chrono::NaiveDateTime::default(),
            ready: false,
            completed_bars: vec![CompletedBarUpdate {
                source,
                bar: CompletedBar {
                    open: 10.0,
                    high: 11.0,
                    low: 9.0,
                    close: 10.0,
                    volume: Some(1.0),
                },
            }],
            values: vec![
                NamedValue {
                    name: "sample".into(),
                    value: Value::Price(10.0),
                    updated: true,
                },
                NamedValue {
                    name: "divisor".into(),
                    value: Value::Number(0.0),
                    updated: true,
                },
            ],
            trade_slots: vec![],
            feedback: vec![],
        };
        for sample in [10.0, 12.0, 14.0] {
            input.values[0].value = Value::Price(sample);
            strategy.evaluate(&input).unwrap();
        }
        assert_eq!(strategy.material_values, vec![Value::Price(12.0)]);
        input.values[0].value = Value::Price(16.0);
        input.ready = true;
        assert!(matches!(
            strategy.evaluate(&input),
            Err(EvaluationError::DivisionByZero { .. })
        ));
        assert_eq!(strategy.material_values, vec![Value::Price(12.0)]);
        assert_eq!(strategy.state_id(), "idle");
        assert!(strategy.terminal);
        let context = MaterialEvalContext {
            input: &input,
            input_updates: &[true],
            any_input_updates: &[true],
            feedback: &[],
            retained_feedback: &[],
        };
        let mut retained = strategy.materials[0].evaluator.clone_box();
        let actual = retained.evaluate(&[Value::Price(20.0)], &context).unwrap();
        assert_eq!(
            actual,
            Value::Price(if key == crate::MATERIAL_STRICT_SMA {
                46.0 / 3.0
            } else {
                16.0
            })
        );
    }
}