sandbox-quant 1.0.8

Exchange-truth trading core for Binance Spot and Futures
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 crate::app::bootstrap::BinanceMode;
use crate::command::recorder::{
    complete_recorder_input, parse_recorder_shell_input, recorder_help_text, RecorderCommand,
    RecorderShellInput,
};
use crate::record::coordination::RecorderCoordination;
use crate::recorder_app::runtime::{MarketDataRecorder, RecorderState};
use crate::terminal::app::{TerminalApp, TerminalEvent, TerminalMode};
use crate::terminal::completion::ShellCompletion;
use crate::ui::recorder_output::render_live_recorder_status;

pub struct RecorderTerminal {
    pub mode: BinanceMode,
    pub base_dir: String,
    pub recorder: MarketDataRecorder,
    pub coordination: RecorderCoordination,
    pub manual_symbols: Vec<String>,
}

impl RecorderTerminal {
    pub fn new(mode: BinanceMode, base_dir: impl Into<String>) -> Self {
        let base_dir = base_dir.into();
        Self {
            mode,
            recorder: MarketDataRecorder::new(base_dir.clone()),
            coordination: RecorderCoordination::new(base_dir.clone()),
            base_dir,
            manual_symbols: Vec::new(),
        }
    }

    fn sync_strategy_symbols(&mut self) -> Result<Vec<String>, String> {
        let strategy_symbols = self
            .coordination
            .strategy_symbols(self.mode)
            .map_err(|error| error.to_string())?;
        if self.recorder.status(self.mode).state == RecorderState::Running {
            self.recorder
                .update_strategy_symbols(self.mode, strategy_symbols.clone())
                .map_err(|error| error.to_string())?;
        }
        Ok(strategy_symbols)
    }
}

impl TerminalApp for RecorderTerminal {
    fn terminal_mode(&self) -> TerminalMode {
        TerminalMode::Line
    }

    fn intro_panel(&self) -> String {
        format!(
            "╭──────────────────────────────────────────────╮\n│ >_ Sandbox Quant Recorder (v{})              │\n│                                              │\n│ mode:      {:<18} /mode to change │\n│ base_dir:  {:<28} │\n╰──────────────────────────────────────────────╯",
            env!("CARGO_PKG_VERSION"),
            self.mode.as_str(),
            self.base_dir
        )
    }

    fn help_text(&self) -> String {
        recorder_help_text().to_string()
    }

    fn prompt(&self) -> String {
        format!("[recorder:{}] › ", self.mode.as_str())
    }

    fn complete(&self, line: &str) -> Vec<ShellCompletion> {
        complete_recorder_input(line)
    }

    fn execute_line(&mut self, line: &str) -> Result<TerminalEvent, String> {
        match parse_recorder_shell_input(line) {
            Ok(RecorderShellInput::Empty) => Ok(TerminalEvent::NoOutput),
            Ok(RecorderShellInput::Help) => Ok(TerminalEvent::Output(self.help_text())),
            Ok(RecorderShellInput::Exit) => Ok(TerminalEvent::Exit),
            Ok(RecorderShellInput::Mode(mode)) => {
                self.mode = mode;
                Ok(TerminalEvent::Output(format!(
                    "mode switched to {}",
                    self.mode.as_str()
                )))
            }
            Ok(RecorderShellInput::Command(command)) => match command {
                RecorderCommand::Start { symbols } => {
                    self.manual_symbols = symbols;
                    let strategy_symbols = self.sync_strategy_symbols()?;
                    let status = if self.recorder.status(self.mode).state == RecorderState::Running
                    {
                        self.recorder
                            .update_manual_symbols(self.mode, self.manual_symbols.clone())
                            .map_err(|error| error.to_string())?;
                        self.recorder.status(self.mode)
                    } else {
                        self.recorder
                            .start(self.mode, self.manual_symbols.clone(), strategy_symbols)
                            .map_err(|error| error.to_string())?
                    };
                    Ok(TerminalEvent::Output(render_live_recorder_status(
                        "record started",
                        &status,
                    )))
                }
                RecorderCommand::Status => {
                    let _ = self.sync_strategy_symbols()?;
                    let status = self.recorder.status(self.mode);
                    Ok(TerminalEvent::Output(render_live_recorder_status(
                        "record status",
                        &status,
                    )))
                }
                RecorderCommand::Stop => {
                    let status = self
                        .recorder
                        .stop(self.mode)
                        .map_err(|error| error.to_string())?;
                    Ok(TerminalEvent::Output(render_live_recorder_status(
                        "record stopped",
                        &status,
                    )))
                }
            },
            Err(error) => Err(error),
        }
    }
}