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
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221

#![allow(dead_code)]
//! Euro area macro-economic data from Jin10 datacenter.

use crate::client::AkShareClient;
use crate::error::Result;
use crate::types::MacroDataPoint;

use super::shared::fetch_jin10_report;

// ---------------------------------------------------------------------------
// Jin10 datacenter — Euro area macro indicators
// ---------------------------------------------------------------------------

impl AkShareClient {
    /// Euro area GDP YoY (欧元区季度GDP年率).
    pub async fn euro_gdp_yoy(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "84", "Euro GDP YoY").await
    }

    /// Euro area CPI MoM (欧元区CPI月率).
    pub async fn euro_cpi_mom(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "84", "Euro CPI MoM").await
    }

    /// Euro area CPI YoY (欧元区CPI年率).
    pub async fn euro_cpi_yoy(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "8", "Euro CPI YoY").await
    }

    /// Euro area PPI MoM (欧元区PPI月率).
    pub async fn euro_ppi_mom(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "36", "Euro PPI MoM").await
    }

    /// Euro area retail sales MoM (欧元区零售销售月率).
    pub async fn euro_retail_sales_mom(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "38", "Euro Retail Sales MoM").await
    }

    /// Euro area employment change QoQ (欧元区就业人数季率).
    pub async fn euro_employment_change_qoq(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "14", "Euro Employment Change QoQ").await
    }

    /// Euro area unemployment rate (欧元区失业率).
    pub async fn euro_unemployment_rate(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "46", "Euro Unemployment Rate").await
    }

    /// Euro area trade balance (欧元区未季调贸易帐).
    pub async fn euro_trade_balance(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "43", "Euro Trade Balance").await
    }

    /// Euro area current account MoM (欧元区经常帐).
    pub async fn euro_current_account_mom(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "11", "Euro Current Account MoM").await
    }

    /// Euro area industrial production MoM (欧元区工业产出月率).
    pub async fn euro_industrial_production_mom(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "19", "Euro Industrial Production MoM").await
    }

    /// Euro area manufacturing PMI (欧元区制造业PMI初值).
    pub async fn euro_manufacturing_pmi(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "30", "Euro Manufacturing PMI").await
    }

    /// Euro area services PMI (欧元区服务业PMI).
    pub async fn euro_services_pmi(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "41", "Euro Services PMI").await
    }

    /// Euro area ZEW economic sentiment (欧元区ZEW经济景气指数).
    pub async fn euro_zew_economic_sentiment(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "48", "Euro ZEW Economic Sentiment").await
    }

    /// Euro area Sentix investor confidence (欧元区Sentix投资者信心指数).
    pub async fn euro_sentix_investor_confidence(&self) -> Result<Vec<MacroDataPoint>> {
        fetch_jin10_report(self, "40", "Euro Sentix Investor Confidence").await
    }
}

// ---------------------------------------------------------------------------
// Jin10 CDN — LME data
// ---------------------------------------------------------------------------

use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Jin10CdnResp {
    values: Option<serde_json::Value>,
    keys: Option<Vec<serde_json::Value>>,
}

impl AkShareClient {
    /// LME holdings report (伦敦金属交易所持仓报告).
    pub async fn euro_lme_holding(&self) -> Result<Vec<MacroDataPoint>> {
        let url = "https://cdn.jin10.com/data_center/reports/lme_position.json";
        let resp: Jin10CdnResp = self.get(url).send().await?.json().await?;

        let values = resp.values.unwrap_or_default();
        let mut items = Vec::new();
        if let Some(obj) = values.as_object() {
            for (date, row) in obj {
                if let Some(cols) = row.as_object() {
                    for (col_name, col_data) in cols {
                        if let Some(arr) = col_data.as_array()
                            && let Some(val) = arr.first().and_then(serde_json::Value::as_f64)
                        {
                            items.push(MacroDataPoint {
                                date: date.clone(),
                                value: val,
                                name: format!("LME Holding {col_name}"),
                            });
                        }
                    }
                }
            }
        }
        items.sort_by(|a, b| a.date.cmp(&b.date));
        Ok(items)
    }

    /// LME stock report (伦敦金属交易所库存报告).
    pub async fn euro_lme_stock(&self) -> Result<Vec<MacroDataPoint>> {
        let url = "https://cdn.jin10.com/data_center/reports/lme_stock.json";
        let resp: Jin10CdnResp = self.get(url).send().await?.json().await?;

        let values = resp.values.unwrap_or_default();
        let mut items = Vec::new();
        if let Some(obj) = values.as_object() {
            for (date, row) in obj {
                if let Some(cols) = row.as_object() {
                    for (col_name, col_data) in cols {
                        if let Some(arr) = col_data.as_array()
                            && let Some(val) = arr.first().and_then(serde_json::Value::as_f64)
                        {
                            items.push(MacroDataPoint {
                                date: date.clone(),
                                value: val,
                                name: format!("LME Stock {col_name}"),
                            });
                        }
                    }
                }
            }
        }
        items.sort_by(|a, b| a.date.cmp(&b.date));
        Ok(items)
    }
}

// Python-compatible aliases
impl AkShareClient {
    pub async fn macro_euro_cpi_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_cpi_mom().await
    }

    pub async fn macro_euro_cpi_yoy(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_cpi_yoy().await
    }

    pub async fn macro_euro_current_account_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_current_account_mom().await
    }

    pub async fn macro_euro_employment_change_qoq(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_employment_change_qoq().await
    }

    pub async fn macro_euro_gdp_yoy(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_gdp_yoy().await
    }

    pub async fn macro_euro_industrial_production_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_industrial_production_mom().await
    }

    pub async fn macro_euro_lme_holding(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_lme_holding().await
    }

    pub async fn macro_euro_lme_stock(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_lme_stock().await
    }

    pub async fn macro_euro_manufacturing_pmi(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_manufacturing_pmi().await
    }

    pub async fn macro_euro_ppi_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_ppi_mom().await
    }

    pub async fn macro_euro_retail_sales_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_retail_sales_mom().await
    }

    pub async fn macro_euro_sentix_investor_confidence(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_sentix_investor_confidence().await
    }

    pub async fn macro_euro_services_pmi(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_services_pmi().await
    }

    pub async fn macro_euro_trade_balance(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_trade_balance().await
    }

    pub async fn macro_euro_zew_economic_sentiment(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_zew_economic_sentiment().await
    }

    pub async fn macro_euro_unemployment_rate_mom(&self) -> Result<Vec<MacroDataPoint>> {
        self.euro_unemployment_rate().await
    }
}