akshare 0.1.2

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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

//! Fund portfolio data from Eastmoney.

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

impl AkShareClient {
    /// Fetch fund portfolio holdings from Eastmoney.
    pub async fn fund_portfolio_hold_em(
        &self,
        symbol: &str,
        _date: &str,
    ) -> Result<Vec<serde_json::Value>> {
        let resp = self
            .get("https://fundf10.eastmoney.com/FundArchivesDatas.aspx")
            .query(&[
                ("type", "jjcc"),
                ("code", symbol),
                ("topline", "10"),
                ("year", ""),
                ("month", ""),
                ("rt", "0.123"),
            ])
            .header(
                "Referer",
                format!("https://fundf10.eastmoney.com/ccmx_{symbol}.html").as_str(),
            )
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        let _text = resp.text().await.map_err(Error::from)?;
        Err(Error::decode(format!(
            "fund portfolio requires HTML parsing for {symbol}"
        )))
    }

    /// Fetch fund bond holdings from Eastmoney.
    pub async fn fund_portfolio_bond_hold_em(
        &self,
        symbol: &str,
    ) -> Result<Vec<serde_json::Value>> {
        self.fund_portfolio_hold_em(symbol, "").await
    }

    /// Fetch fund asset allocation from Eastmoney.
    pub async fn fund_portfolio_asset_allocation_em(
        &self,
        symbol: &str,
    ) -> Result<Vec<serde_json::Value>> {
        self.fund_portfolio_hold_em(symbol, "").await
    }

    /// Fetch fund portfolio industry allocation (Python: fund_portfolio_industry_allocation_em).
    pub async fn fund_portfolio_industry_allocation_em(
        &self,
        symbol: &str,
    ) -> Result<Vec<serde_json::Value>> {
        let response = self
            .get("https://api.fund.eastmoney.com/f10/HYPZ/")
            .header("Referer", "https://fundf10.eastmoney.com/")
            .query(&[
                ("fundCode", symbol),
                ("year", ""),
                ("callback", "jQuery183006997159478989867_1648016188499"),
            ])
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        let text = response.text().await.map_err(Error::from)?;
        // Response is JSONP; extract JSON
        let json_start = text.find('{').unwrap_or(0);
        let json_end = text.rfind('}').map_or(text.len(), |i| i + 1);
        let json_str = &text[json_start..json_end];

        let root: serde_json::Value = serde_json::from_str(json_str)
            .map_err(|e| Error::decode(format!("industry alloc JSON parse: {e}")))?;

        let quarters = root
            .get("Data")
            .and_then(|d| d.get("QuarterInfos"))
            .and_then(|q| q.as_array())
            .ok_or_else(|| Error::not_found(format!("no industry allocation for {symbol}")))?;

        let mut result = Vec::new();
        for quarter in quarters {
            let items = quarter
                .get("HYPZInfo")
                .and_then(|h| h.as_array())
                .cloned()
                .unwrap_or_default();
            for item in items {
                result.push(item);
            }
        }
        if result.is_empty() {
            return Err(Error::not_found(format!(
                "no industry allocation for {symbol}"
            )));
        }
        Ok(result)
    }

    /// Fetch fund portfolio major changes (Python: fund_portfolio_change_em).
    ///
    /// `symbol`: fund code.
    /// `indicator`: "累计买入" or "累计卖出".
    pub async fn fund_portfolio_change_em(
        &self,
        symbol: &str,
        indicator: &str,
    ) -> Result<Vec<serde_json::Value>> {
        let zdbd = match indicator {
            "累计买入" => "1",
            "累计卖出" => "2",
            _ => {
                return Err(Error::invalid_input(format!(
                    "unsupported indicator: {indicator}"
                )));
            }
        };

        let response = self
            .get("https://fundf10.eastmoney.com/FundArchivesDatas.aspx")
            .query(&[
                ("type", "zdbd"),
                ("code", symbol),
                ("zdbd", zdbd),
                ("year", ""),
                ("rt", "0.913877030254846"),
            ])
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        let text = response.text().await.map_err(Error::from)?;
        let json_start = text.find('{').unwrap_or(0);
        let json_end = text.rfind('}').map_or(text.len(), |i| i + 1);
        let json_str = &text[json_start..json_end];

        let root: serde_json::Value = serde_json::from_str(json_str)
            .map_err(|e| Error::decode(format!("portfolio change JSON parse: {e}")))?;

        let content = root
            .get("content")
            .and_then(|c| c.as_str())
            .ok_or_else(|| Error::not_found(format!("no portfolio change data for {symbol}")))?;

        // Content is HTML; we return it as a raw value for now.
        Ok(vec![serde_json::json!({
            "fund_code": symbol,
            "indicator": indicator,
            "html_content": content,
        })])
    }
}