fugle-marketdata-core 0.5.1

Internal kernel for the Fugle market data SDK. End users should depend on `fugle-marketdata` instead.
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
127
128
129
130
131
132
133
134
135
136
137
138

//! Common types shared across market data models

use serde::{Deserialize, Serialize};

/// Common response metadata for all API responses
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "python", pyo3::prelude::pyclass)]
#[cfg_attr(feature = "js", napi_derive::napi(object))]
pub struct ResponseMeta {
    /// Trading date (YYYY-MM-DD)
    pub date: String,

    /// Security type (e.g., "EQUITY", "ODDLOT")
    #[serde(rename = "type")]
    pub data_type: Option<String>,

    /// Exchange code (e.g., "TWSE", "TPEx")
    pub exchange: Option<String>,

    /// Market (e.g., "TSE", "OTC")
    pub market: Option<String>,

    /// Stock symbol
    pub symbol: String,
}

/// Price level for order book (bid/ask)
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "python", pyo3::prelude::pyclass)]
#[cfg_attr(feature = "js", napi_derive::napi(object))]
pub struct PriceLevel {
    /// Price at this level
    pub price: f64,

    /// Size (volume) at this level
    pub size: i64,
}

/// Trade execution info (used in quote.lastTrade, quote.lastTrial)
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "python", pyo3::prelude::pyclass)]
#[cfg_attr(feature = "js", napi_derive::napi(object))]
pub struct TradeInfo {
    /// Best bid price at trade time
    pub bid: Option<f64>,

    /// Best ask price at trade time
    pub ask: Option<f64>,

    /// Trade price
    pub price: f64,

    /// Trade size
    pub size: i64,

    /// Trade timestamp (Unix milliseconds)
    pub time: i64,
}

/// Total trading statistics
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "python", pyo3::prelude::pyclass)]
#[cfg_attr(feature = "js", napi_derive::napi(object))]
pub struct TotalStats {
    /// Total trade value. Absent on FutOpt aggregates — server sends
    /// `{time, totalBidMatch, totalAskMatch, tradeVolume}` with no
    /// `tradeValue`, so a missing field must not fail deserialization.
    #[serde(rename = "tradeValue", default)]
    pub trade_value: f64,

    /// Total trade volume
    #[serde(rename = "tradeVolume", default)]
    pub trade_volume: i64,

    /// Volume traded at bid
    #[serde(rename = "tradeVolumeAtBid")]
    pub trade_volume_at_bid: Option<i64>,

    /// Volume traded at ask
    #[serde(rename = "tradeVolumeAtAsk")]
    pub trade_volume_at_ask: Option<i64>,

    /// Number of transactions
    pub transaction: Option<i64>,

    /// Timestamp
    pub time: Option<i64>,
}

/// Trading halt status
#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
#[cfg_attr(feature = "python", pyo3::prelude::pyclass)]
#[cfg_attr(feature = "js", napi_derive::napi(object))]
pub struct TradingHalt {
    /// Whether trading is halted
    #[serde(rename = "isHalted")]
    pub is_halted: bool,

    /// Halt timestamp
    pub time: Option<i64>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_price_level_deserialization() {
        let json = r#"{"price": 100.5, "size": 1000}"#;
        let level: PriceLevel = serde_json::from_str(json).unwrap();
        assert_eq!(level.price, 100.5);
        assert_eq!(level.size, 1000);
    }

    #[test]
    fn test_trade_info_deserialization() {
        let json = r#"{"bid": 100.0, "ask": 100.5, "price": 100.5, "size": 500, "time": 1704067200000}"#;
        let info: TradeInfo = serde_json::from_str(json).unwrap();
        assert_eq!(info.price, 100.5);
        assert_eq!(info.size, 500);
        assert_eq!(info.time, 1704067200000);
    }

    #[test]
    fn test_response_meta_deserialization() {
        let json = r#"{
            "date": "2024-01-15",
            "type": "EQUITY",
            "exchange": "TWSE",
            "market": "TSE",
            "symbol": "2330"
        }"#;
        let meta: ResponseMeta = serde_json::from_str(json).unwrap();
        assert_eq!(meta.date, "2024-01-15");
        assert_eq!(meta.symbol, "2330");
        assert_eq!(meta.data_type.as_deref(), Some("EQUITY"));
    }
}