akshare 0.1.0

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

//! CFLP (中国物流与采购联合会) logistics price and volume indices.

use serde::Deserialize;

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

// ---------------------------------------------------------------------------
// Wire types
// ---------------------------------------------------------------------------

#[derive(Debug, Deserialize)]
struct CflpEnvelope {
    chart1: Option<CflpChart>,
    chart2: Option<CflpChart>,
    chart3: Option<CflpChart>,
}

#[derive(Debug, Deserialize)]
#[allow(non_snake_case)]
struct CflpChart {
    #[serde(default)]
    xLebal: Vec<String>,
    #[serde(default)]
    yLebal: Vec<serde_json::Value>,
}

// ---------------------------------------------------------------------------
// Public API
// ---------------------------------------------------------------------------

impl AkShareClient {
    /// 中国公路物流运价指数.
    ///
    /// `symbol` is one of: "周指数", "月指数", "季度指数", "年度指数".
    pub async fn index_price_cflp(&self, symbol: &str) -> Result<Vec<CflpIndexPoint>> {
        let exp_type = match symbol {
            "周指数" => "2",
            "月指数" => "3",
            "季度指数" => "4",
            "年度指数" => "5",
            _ => {
                return Err(Error::invalid_input(format!(
                    "unsupported CFLP symbol: {symbol}"
                )));
            }
        };

        let response = self
            .post("http://index.0256.cn/expcenter_trend.action")
            .header("Origin", "http://index.0256.cn")
            .header("Referer", "http://index.0256.cn/expx.htm")
            .form(&[
                ("marketId", "1"),
                ("attribute1", "5"),
                ("exponentTypeId", exp_type),
                ("cateId", "2"),
                ("attribute2", "华北"),
                ("city", ""),
                ("startLine", ""),
                ("endLine", ""),
            ])
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        parse_cflp_response(response).await
    }

    /// 中国公路物流运量指数.
    ///
    /// `symbol` is one of: "月指数", "季度指数", "年度指数".
    pub async fn index_volume_cflp(&self, symbol: &str) -> Result<Vec<CflpIndexPoint>> {
        let exp_type = match symbol {
            "月指数" => "3",
            "季度指数" => "4",
            "年度指数" => "5",
            _ => {
                return Err(Error::invalid_input(format!(
                    "unsupported CFLP symbol: {symbol}"
                )));
            }
        };

        let response = self
            .post("http://index.0256.cn/volume_query.action")
            .header("Origin", "http://index.0256.cn")
            .header("Referer", "http://index.0256.cn/expx.htm")
            .form(&[
                ("type", "1"),
                ("marketId", "1"),
                ("expTypeId", exp_type),
                ("startDate1", ""),
                ("endDate1", ""),
                ("city", ""),
                ("startDate3", ""),
                ("endDate3", ""),
            ])
            .send()
            .await
            .map_err(Error::from)?
            .error_for_status()
            .map_err(Error::from)?;

        parse_cflp_response(response).await
    }
}

async fn parse_cflp_response(response: reqwest::Response) -> Result<Vec<CflpIndexPoint>> {
    let payload: CflpEnvelope = response.json().await.map_err(Error::from)?;

    let chart1 = payload
        .chart1
        .ok_or_else(|| Error::upstream("cflp response missing chart1"))?;
    let chart2 = payload.chart2.unwrap_or(CflpChart {
        xLebal: vec![],
        yLebal: vec![],
    });
    let chart3 = payload.chart3.unwrap_or(CflpChart {
        xLebal: vec![],
        yLebal: vec![],
    });

    let len = chart1.xLebal.len();
    let mut points = Vec::with_capacity(len);

    for i in 0..len {
        let date = chart1.xLebal.get(i).cloned().unwrap_or_default();
        let base = chart1.yLebal.get(i).and_then(|v| v.as_f64()).unwrap_or(0.0);
        let mom = chart2.yLebal.get(i).and_then(|v| v.as_f64()).unwrap_or(0.0);
        let yoy = chart3.yLebal.get(i).and_then(|v| v.as_f64()).unwrap_or(0.0);
        points.push(CflpIndexPoint {
            date,
            base_index: base,
            mom_index: mom,
            yoy_index: yoy,
        });
    }

    if points.is_empty() {
        return Err(Error::not_found("cflp returned no data"));
    }
    Ok(points)
}

#[cfg(test)]
mod tests {
    #[test]
    fn test_placeholder() {
        // CFLP functions require network access.
    }
}