tushare-api 1.2.6

A comprehensive Rust client library for accessing Tushare financial 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

//! 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::traits::FromTushareValueWithFormat;
#[cfg(feature = "chrono")]
use crate::error::TushareError;

#[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)
            )),
        }
    }
}