tushare-rs-pro 0.1.1

Rust SDK for Tushare Pro API — 77 predefined data models, 12 domains, derive macro, async/await
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

//! Custom date format implementations for FromTushareValueWithFormat trait
//!
//! This module provides implementations for chrono date/time types that support
//! custom date format parsing through the `#[tushare(date_format = "...")]` attribute.

#[cfg(feature = "chrono")]
use crate::error::TushareError;
#[cfg(feature = "chrono")]
use crate::traits::FromTushareValueWithFormat;

#[cfg(feature = "chrono")]
impl FromTushareValueWithFormat for chrono::NaiveDate {
    fn from_tushare_value_with_format(
        value: &serde_json::Value,
        format: &str,
    ) -> Result<Self, TushareError> {
        match value {
            serde_json::Value::String(s) => {
                // Try parsing with the custom format
                chrono::NaiveDate::parse_from_str(s, format).map_err(|e| {
                    TushareError::ParseError(format!(
                        "Failed to parse date '{}' with format '{}': {}",
                        s, format, e
                    ))
                })
            }
            serde_json::Value::Number(n) => {
                // For numeric values, try to parse as YYYYMMDD first, then use custom format
                if let Some(i) = n.as_i64() {
                    let date_str = i.to_string();

                    // Try YYYYMMDD format first for numeric values
                    if date_str.len() == 8 {
                        if let Ok(date) = chrono::NaiveDate::parse_from_str(&date_str, "%Y%m%d") {
                            return Ok(date);
                        }
                    }

                    // Fall back to custom format
                    chrono::NaiveDate::parse_from_str(&date_str, format).map_err(|e| {
                        TushareError::ParseError(format!(
                            "Failed to parse numeric date '{}' with format '{}': {}",
                            date_str, format, e
                        ))
                    })
                } else {
                    Err(TushareError::ParseError(format!(
                        "Invalid numeric date value: {}",
                        n
                    )))
                }
            }
            _ => Err(TushareError::ParseError(format!(
                "Expected string or number for date parsing, got: {:?}",
                value
            ))),
        }
    }
}

#[cfg(feature = "chrono")]
impl FromTushareValueWithFormat for chrono::NaiveDateTime {
    fn from_tushare_value_with_format(
        value: &serde_json::Value,
        format: &str,
    ) -> Result<Self, TushareError> {
        match value {
            serde_json::Value::String(s) => {
                // Try parsing with the custom format
                chrono::NaiveDateTime::parse_from_str(s, format).map_err(|e| {
                    TushareError::ParseError(format!(
                        "Failed to parse datetime '{}' with format '{}': {}",
                        s, format, e
                    ))
                })
            }
            serde_json::Value::Number(n) => {
                // For numeric values, convert to string and try parsing
                let datetime_str = n.to_string();
                chrono::NaiveDateTime::parse_from_str(&datetime_str, format).map_err(|e| {
                    TushareError::ParseError(format!(
                        "Failed to parse numeric datetime '{}' with format '{}': {}",
                        datetime_str, format, e
                    ))
                })
            }
            _ => Err(TushareError::ParseError(format!(
                "Expected string or number for datetime parsing, got: {:?}",
                value
            ))),
        }
    }
}

#[cfg(feature = "chrono")]
impl FromTushareValueWithFormat for chrono::DateTime<chrono::Utc> {
    fn from_tushare_value_with_format(
        value: &serde_json::Value,
        format: &str,
    ) -> Result<Self, TushareError> {
        match value {
            serde_json::Value::String(s) => {
                // Try parsing with the custom format
                chrono::DateTime::parse_from_str(s, format)
                    .map(|dt| dt.with_timezone(&chrono::Utc))
                    .map_err(|e| {
                        TushareError::ParseError(format!(
                            "Failed to parse UTC datetime '{}' with format '{}': {}",
                            s, format, e
                        ))
                    })
            }
            serde_json::Value::Number(n) => {
                // For numeric values, convert to string and try parsing
                let datetime_str = n.to_string();
                chrono::DateTime::parse_from_str(&datetime_str, format)
                    .map(|dt| dt.with_timezone(&chrono::Utc))
                    .map_err(|e| {
                        TushareError::ParseError(format!(
                            "Failed to parse numeric UTC datetime '{}' with format '{}': {}",
                            datetime_str, format, e
                        ))
                    })
            }
            _ => Err(TushareError::ParseError(format!(
                "Expected string or number for UTC datetime parsing, got: {:?}",
                value
            ))),
        }
    }
}