akshare 0.1.1

100% pure Rust implementation of akshare — unified access to Chinese and global financial market data APIs
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
139
140
141
142

#![allow(dead_code)]
//! Chinese bond spot and daily data from Sina Finance.

use serde::Deserialize;

use crate::client::AkShareClient;
use crate::error::{Error, Result};
use crate::types::BondSnapshot;

#[derive(Debug, Deserialize)]
struct SinaBondQuote {
    symbol: Option<String>,
    name: Option<String>,
    trade: Option<String>,
    change: Option<String>,
    change_pct: Option<String>,
    buy: Option<String>,
    sell: Option<String>,
    settlement: Option<String>,
    open: Option<String>,
    high: Option<String>,
    low: Option<String>,
    volume: Option<String>,
    amount: Option<String>,
}

impl AkShareClient {
    /// Fetch real-time Chinese bond spot quotes from Sina Finance.
    ///
    /// Returns up to `limit` pages of bond quotes (80 items per page).
    /// Note: heavy scraping may trigger IP bans.
    pub async fn bond_zh_hs_spot(&self, limit: usize) -> Result<Vec<BondSnapshot>> {
        let mut all_items = Vec::new();
        let today = crate::util::today_iso();

        for page in 1..=limit {
            let page_str = page.to_string();
            let resp = self
                                .get("https://vip.stock.finance.sina.com.cn/quotes_service/api/json_v2.php/Market_Center.getHQNodeData")
                .query(&[
                    ("page", page_str.as_str()),
                    ("num", "80"),
                    ("sort", "changepercent"),
                    ("asc", "0"),
                    ("node", "hs_z"),
                    ("symbol", ""),
                    ("_s_r_a", "page"),
                ])
                .send()
                .await
                .map_err(Error::from)?
                .error_for_status()
                .map_err(Error::from)?;

            let text = resp.text().await.map_err(Error::from)?;
            if text.is_empty() || text == "null" {
                break;
            }
            let items: Vec<SinaBondQuote> = match serde_json::from_str(&text) {
                Ok(v) => v,
                Err(_) => break,
            };

            for item in items {
                let symbol = item.symbol.unwrap_or_default();
                if symbol.is_empty() {
                    continue;
                }
                all_items.push(BondSnapshot {
                    symbol,
                    name: item.name.unwrap_or_default(),
                    date: today.clone(),
                    close: item.trade.unwrap_or_default().parse().unwrap_or(0.0),
                    change_pct: item.change_pct.unwrap_or_default().parse().unwrap_or(0.0),
                    yield_rate: None,
                    credit_rating: None,
                });
            }
        }

        if all_items.is_empty() {
            return Err(Error::not_found("sina returned no bond spot data"));
        }
        Ok(all_items)
    }

    /// Fetch historical daily data for a Chinese bond from Sina Finance.
    ///
    /// `symbol` is in Sina format (e.g. "sh010107").
    pub async fn bond_zh_hs_daily(&self, symbol: &str) -> Result<Vec<BondSnapshot>> {
        let now = chrono::Utc::now().format("%Y_%m_%d").to_string();
        let url = format!("https://hq.sinajs.cn/lb/{symbol}_{now}");
        let resp = self
            .get(&url)
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        let text = resp.text().await.map_err(Error::from)?;
        if text.is_empty() {
            return Err(Error::not_found(format!(
                "sina returned no data for {symbol}"
            )));
        }

        // Sina returns encrypted JS; we attempt to parse the data section.
        // For now return the raw response as unsupported.
        Err(Error::decode(format!(
            "sina bond daily data requires JS decryption; use eastmoney_klines instead for symbol {symbol}"
        )))
    }
}

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

    #[test]
    fn test_sina_bond_quote_deserialize() {
        let j = json!({
            "symbol": "sh010107",
            "name": "21国债(7)",
            "trade": "100.50",
            "change": "0.30",
            "change_pct": "0.30",
            "buy": "100.40",
            "sell": "100.60",
            "settlement": "100.20",
            "open": "100.30",
            "high": "100.80",
            "low": "100.10",
            "volume": "5000",
            "amount": "502500"
        });
        let q: SinaBondQuote = serde_json::from_value(j).unwrap();
        assert_eq!(q.symbol.unwrap(), "sh010107");
        assert_eq!(q.name.unwrap(), "21国债(7)");
    }
}