flowsurface-data 0.8.8

Data aggregation, indexing, and configuration utilities for Flowsurface
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

use exchange::{PushFrequency, Ticker, TickerInfo, Timeframe, adapter::StreamKind};
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum PersistStreamKind {
    Kline {
        ticker: Ticker,
        timeframe: Timeframe,
    },
    Depth(PersistDepth),
    Trades {
        ticker: Ticker,
    },
    /// Deprecated combined stream, kept for backward compatibility.
    /// Will be converted to separate Depth and Trades on load.
    DepthAndTrades(PersistDepth),
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub struct PersistDepth {
    pub ticker: Ticker,
    #[serde(default = "default_depth_aggr")]
    pub depth_aggr: exchange::adapter::StreamTicksize,
    #[serde(default = "default_push_freq")]
    pub push_freq: PushFrequency,
}

impl From<StreamKind> for PersistStreamKind {
    fn from(stream: StreamKind) -> Self {
        match stream {
            StreamKind::Kline {
                ticker_info,
                timeframe,
            } => PersistStreamKind::Kline {
                ticker: ticker_info.ticker,
                timeframe,
            },
            StreamKind::Depth {
                ticker_info,
                depth_aggr,
                push_freq,
            } => PersistStreamKind::Depth(PersistDepth {
                ticker: ticker_info.ticker,
                depth_aggr,
                push_freq,
            }),
            StreamKind::Trades { ticker_info } => PersistStreamKind::Trades {
                ticker: ticker_info.ticker,
            },
        }
    }
}

impl PersistStreamKind {
    /// Try to convert into runtime StreamKind list. `resolver` should return Some(TickerInfo) for a ticker,
    /// otherwise the conversion fails (so caller can trigger a refresh / fetch).
    pub fn into_stream_kinds<F>(self, mut resolver: F) -> Result<Vec<StreamKind>, String>
    where
        F: FnMut(&Ticker) -> Option<TickerInfo>,
    {
        match self {
            PersistStreamKind::Kline { ticker, timeframe } => resolver(&ticker)
                .map(|ti| {
                    vec![StreamKind::Kline {
                        ticker_info: ti,
                        timeframe,
                    }]
                })
                .ok_or_else(|| format!("TickerInfo not found for {}", ticker)),
            PersistStreamKind::Depth(d) => resolver(&d.ticker)
                .map(|ti| {
                    vec![StreamKind::Depth {
                        ticker_info: ti,
                        depth_aggr: d.depth_aggr,
                        push_freq: d.push_freq,
                    }]
                })
                .ok_or_else(|| format!("TickerInfo not found for {}", d.ticker)),
            PersistStreamKind::Trades { ticker } => resolver(&ticker)
                .map(|ti| vec![StreamKind::Trades { ticker_info: ti }])
                .ok_or_else(|| format!("TickerInfo not found for {}", ticker)),
            PersistStreamKind::DepthAndTrades(d) => resolver(&d.ticker)
                .map(|ti| {
                    vec![
                        StreamKind::Depth {
                            ticker_info: ti,
                            depth_aggr: d.depth_aggr,
                            push_freq: d.push_freq,
                        },
                        StreamKind::Trades { ticker_info: ti },
                    ]
                })
                .ok_or_else(|| format!("TickerInfo not found for {}", d.ticker)),
        }
    }
}

fn default_depth_aggr() -> exchange::adapter::StreamTicksize {
    exchange::adapter::StreamTicksize::Client
}

fn default_push_freq() -> PushFrequency {
    PushFrequency::ServerDefault
}