mirror-github-bspeice
/
dtparse
mirror of https://github.com/bspeice/dtparse
1
0
Fork 0
Code Issues Releases Wiki Activity
dtparse/src/lib.rs

1363 lines
47 KiB
Rust
Raw Blame History

#![deny(missing_docs)]
#![cfg_attr(test, allow(unknown_lints))]
#![cfg_attr(test, deny(warnings))]
//! # dtparse
//! The fully-featured "even I couldn't understand that" time parser.
//! Designed to take in strings and give back sensible dates and times.
//!
//! dtparse has its foundations in the [`dateutil`](dateutil) library for
//! Python, which excels at taking "interesting" strings and trying to make
//! sense of the dates and times they contain. A couple of quick examples
//! from the test cases should give some context:
//!
//! ```rust,ignore (tests-dont-compile-on-old-rust)
//! # extern crate chrono;
//! # extern crate dtparse;
//! use chrono::prelude::*;
//! use dtparse::parse;
//!
//! assert_eq!(
//! parse("2008.12.30"),
//! Ok((NaiveDate::from_ymd(2008, 12, 30).and_hms(0, 0, 0), None))
//! );
//!
//! // It can even handle timezones!
//! assert_eq!(
//! parse("January 4, 2024; 18:30:04 +02:00"),
//! Ok((
//! NaiveDate::from_ymd(2024, 1, 4).and_hms(18, 30, 4),
//! Some(FixedOffset::east(7200))
//! ))
//! );
//! ```
//!
//! And we can even handle fuzzy strings where dates/times aren't the
//! only content if we dig into the implementation a bit!
//!
//! ```rust,ignore (tests-dont-compile-on-old-rust)
//! # extern crate chrono;
//! # extern crate dtparse;
//! use chrono::prelude::*;
//! use dtparse::Parser;
//! # use std::collections::HashMap;
//!
//! let mut p = Parser::default();
//! assert_eq!(
//! p.parse(
//! "I first released this library on the 17th of June, 2018.",
//! None, None,
//! true /* turns on fuzzy mode */,
//! true /* gives us the tokens that weren't recognized */,
//! None, false, &HashMap::new()
//! ),
//! Ok((
//! NaiveDate::from_ymd(2018, 6, 17).and_hms(0, 0, 0),
//! None,
//! Some(vec!["I first released this library on the ",
//! " of ", ", "].iter().map(|&s| s.into()).collect())
//! ))
//! );
//! ```
//!
//! Further examples can be found in the `examples` directory on international usage.
//!
//! # Usage
//!
//! `dtparse` requires a minimum Rust version of 1.28 to build, but is tested on Windows, OSX,
//! BSD, Linux, and WASM. The build is also compiled against the iOS and Android SDK's, but is not
//! tested against them.
//!
//! [dateutil]: https://github.com/dateutil/dateutil
#[macro_use]
extern crate lazy_static;
extern crate chrono;
extern crate num_traits;
extern crate rust_decimal;
#[cfg(test)]
extern crate base64;
use chrono::Datelike;
use chrono::Duration;
use chrono::FixedOffset;
use chrono::Local;
use chrono::NaiveDate;
use chrono::NaiveDateTime;
use chrono::NaiveTime;
use chrono::Timelike;
use num_traits::cast::ToPrimitive;
use rust_decimal::Decimal;
use rust_decimal::Error as DecimalError;
use std::cmp::min;
use std::collections::HashMap;
use std::error::Error;
use std::fmt;
use std::num::ParseIntError;
use std::str::FromStr;
use std::vec::Vec;
mod tokenize;
mod weekday;
#[cfg(test)]
mod tests;
use tokenize::Tokenizer;
use weekday::day_of_week;
use weekday::DayOfWeek;
lazy_static! {
static ref ZERO: Decimal = Decimal::new(0, 0);
static ref ONE: Decimal = Decimal::new(1, 0);
static ref TWENTY_FOUR: Decimal = Decimal::new(24, 0);
static ref SIXTY: Decimal = Decimal::new(60, 0);
static ref DEFAULT_PARSER: Parser = Parser::default();
}
impl From<DecimalError> for ParseError {
fn from(err: DecimalError) -> Self {
ParseError::InvalidNumeric(format!("{}", err))
}
}
impl From<ParseIntError> for ParseError {
fn from(err: ParseIntError) -> Self {
ParseError::InvalidNumeric(format!("{}", err))
}
}
/// Potential errors that come up when trying to parse time strings
#[derive(Debug, PartialEq)]
pub enum ParseError {
/// Attempted to specify "AM" or "PM" without indicating an hour
AmPmWithoutHour,
/// Impossible value for a category; the 32nd day of a month is impossible
ImpossibleTimestamp(&'static str),
/// Unable to parse a numeric value from a token expected to be numeric
InvalidNumeric(String),
/// Generally unrecognized date string; please report to maintainer so
/// new test cases can be developed
UnrecognizedFormat,
/// A token the parser did not recognize was in the string, and fuzzy mode was off
UnrecognizedToken(String),
/// A timezone could not be handled; please report to maintainer as the timestring
/// likely exposes a bug in the implementation
TimezoneUnsupported,
/// Parser unable to make sense of year/month/day parameters in the time string;
/// please report to maintainer as the timestring likely exposes a bug in implementation
YearMonthDayError(&'static str),
/// Parser unable to find any date/time-related content in the supplied string
NoDate,
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{:?}", self)
}
}
impl Error for ParseError {}
type ParseResult<I> = Result<I, ParseError>;
pub(crate) fn tokenize(parse_string: &str) -> Vec<String> {
let tokenizer = Tokenizer::new(parse_string);
tokenizer.collect()
}
/// Utility function for `ParserInfo` that helps in constructing
/// the attributes that make up the `ParserInfo` container
pub fn parse_info(vec: Vec<Vec<&str>>) -> HashMap<String, usize> {
let mut m = HashMap::new();
if vec.len() == 1 {
for (i, val) in vec.get(0).unwrap().iter().enumerate() {
m.insert(val.to_lowercase(), i);
}
} else {
for (i, val_vec) in vec.iter().enumerate() {
for val in val_vec {
m.insert(val.to_lowercase(), i);
}
}
}
m
}
/// Container for specific tokens to be recognized during parsing.
///
/// - `jump`: Values that indicate the end of a token for parsing and can be ignored
/// - `weekday`: Names of the days of the week
/// - `months`: Names of the months
/// - `hms`: Names for the units of time - hours, minutes, seconds in English
/// - `ampm`: AM and PM tokens
/// - `utczone`: Tokens indicating a UTC-timezone string
/// - `pertain`: Tokens indicating a "belongs to" relationship; in English this is just "of"
/// - `tzoffset`:
/// - `dayfirst`: Upon encountering an ambiguous date, treat the first value as the day
/// - `yearfirst`: Upon encountering an ambiguous date, treat the first value as the year
/// - `year`: The current year
/// - `century`: The first year in the current century
///
/// Please note that if both `dayfirst` and `yearfirst` are true, years take precedence
/// and will be parsed as "YDM"
#[derive(Debug, PartialEq)]
pub struct ParserInfo {
/// Tokens that can be safely ignored
pub jump: HashMap<String, usize>,
/// Names of all seven weekdays
pub weekday: HashMap<String, usize>,
/// Names of all twelve months
pub months: HashMap<String, usize>,
/// Tokens to indicate a value is in units of hours, minutes, or seconds
pub hms: HashMap<String, usize>,
/// Tokens to indicate a value refers to AM or PM time
pub ampm: HashMap<String, usize>,
/// Tokens to indicate our timestamp is in the UTC timezone
pub utczone: HashMap<String, usize>,
/// Tokens to indicate values "belonging" to other tokens (e.g. 3rd *of* March)
pub pertain: HashMap<String, usize>,
/// Map of timezone names to their offset in seconds
pub tzoffset: HashMap<String, usize>,
/// For ambiguous year/month/day values, and `dayfirst` was not specified as
/// an argument to `Parser`, treat the first observed value as the day.
pub dayfirst: bool,
/// For ambiguous year/month/day values, and `dayfirst` was not specified as
/// an argument to `Parser`, treat the first observed value as the day.
/// Takes priority over `dayfirst`
pub yearfirst: bool,
/// The current year we are parsing values for
pub year: i32,
/// The current year we are parsing values for *modulo* 100
pub century: i32,
}
impl Default for ParserInfo {
/// Create a basic `ParserInfo` object suitable for parsing dates in English
fn default() -> Self {
let year = Local::now().year();
let century = year / 100 * 100;
ParserInfo {
jump: parse_info(vec![vec![
" ", ".", ",", ";", "-", "/", "'", "at", "on", "and", "ad", "m", "t", "of", "st",
"nd", "rd", "th",
]]),
weekday: parse_info(vec![
vec!["Mon", "Monday"],
vec!["Tue", "Tues", "Tuesday"],
vec!["Wed", "Wednesday"],
vec!["Thu", "Thurs", "Thursday"],
vec!["Fri", "Friday"],
vec!["Sat", "Saturday"],
vec!["Sun", "Sunday"],
]),
months: parse_info(vec![
vec!["Jan", "January"],
vec!["Feb", "February"],
vec!["Mar", "March"],
vec!["Apr", "April"],
vec!["May"],
vec!["Jun", "June"],
vec!["Jul", "July"],
vec!["Aug", "August"],
vec!["Sep", "Sept", "September"],
vec!["Oct", "October"],
vec!["Nov", "November"],
vec!["Dec", "December"],
]),
hms: parse_info(vec![
vec!["h", "hour", "hours"],
vec!["m", "minute", "minutes"],
vec!["s", "second", "seconds"],
]),
ampm: parse_info(vec![vec!["am", "a"], vec!["pm", "p"]]),
utczone: parse_info(vec![vec!["UTC", "GMT", "Z"]]),
pertain: parse_info(vec![vec!["of"]]),
tzoffset: parse_info(vec![vec![]]),
dayfirst: false,
yearfirst: false,
year,
century,
}
}
}
impl ParserInfo {
fn jump_index(&self, name: &str) -> bool {
self.jump.contains_key(&name.to_lowercase())
}
fn weekday_index(&self, name: &str) -> Option<usize> {
self.weekday.get(&name.to_lowercase()).cloned()
}
fn month_index(&self, name: &str) -> Option<usize> {
self.months.get(&name.to_lowercase()).map(|u| u + 1)
}
fn hms_index(&self, name: &str) -> Option<usize> {
self.hms.get(&name.to_lowercase()).cloned()
}
fn ampm_index(&self, name: &str) -> Option<bool> {
if let Some(v) = self.ampm.get(&name.to_lowercase()) {
// Python technically uses numbers here, but given that the numbers are
// only 0 and 1, it's easier to use booleans
Some(*v == 1)
} else {
None
}
}
fn pertain_index(&self, name: &str) -> bool {
self.pertain.contains_key(&name.to_lowercase())
}
fn utczone_index(&self, name: &str) -> bool {
self.utczone.contains_key(&name.to_lowercase())
}
fn tzoffset_index(&self, name: &str) -> Option<usize> {
if self.utczone.contains_key(&name.to_lowercase()) {
Some(0)
} else {
self.tzoffset.get(&name.to_lowercase()).cloned()
}
}
fn convertyear(&self, year: i32, century_specified: bool) -> i32 {
let mut year = year;
if year < 100 && !century_specified {
year += self.century;
if year >= self.year + 50 {
year -= 100;
} else if year < self.year - 50 {
year += 100
}
}
year
}
// TODO: Should this be moved elsewhere?
fn validate(&self, res: &mut ParsingResult) -> bool {
if let Some(y) = res.year {
res.year = Some(self.convertyear(y, res.century_specified))
};
if (res.tzoffset == Some(0) && res.tzname.is_none())
|| (res.tzname == Some("Z".to_owned()) || res.tzname == Some("z".to_owned()))
{
res.tzname = Some("UTC".to_owned());
res.tzoffset = Some(0);
} else if res.tzoffset != Some(0)
&& res.tzname.is_some()
&& self.utczone_index(res.tzname.as_ref().unwrap())
{
res.tzoffset = Some(0);
}
true
}
}
fn days_in_month(year: i32, month: i32) -> Result<u32, ParseError> {
let leap_year = match year % 4 {
0 => year % 400 != 0,
_ => false,
};
match month {
2 => {
if leap_year {
Ok(29)
} else {
Ok(28)
}
}
1 | 3 | 5 | 7 | 8 | 10 | 12 => Ok(31),
4 | 6 | 9 | 11 => Ok(30),
_ => Err(ParseError::ImpossibleTimestamp("Invalid month")),
}
}
#[derive(Debug, Hash, PartialEq, Eq)]
enum YMDLabel {
Year,
Month,
Day,
}
#[derive(Debug, Default)]
struct YMD {
_ymd: Vec<i32>, // TODO: This seems like a super weird way to store things
century_specified: bool,
dstridx: Option<usize>,
mstridx: Option<usize>,
ystridx: Option<usize>,
}
impl YMD {
fn len(&self) -> usize {
self._ymd.len()
}
fn could_be_day(&self, val: i32) -> bool {
if self.dstridx.is_some() {
false
} else if self.mstridx.is_none() {
(1 <= val) && (val <= 31)
} else if self.ystridx.is_none() {
// UNWRAP: Earlier condition catches mstridx missing
let month = self._ymd[self.mstridx.unwrap()];
1 <= val && (val <= days_in_month(2000, month).unwrap() as i32)
} else {
// UNWRAP: Earlier conditions prevent us from unsafely unwrapping
let month = self._ymd[self.mstridx.unwrap()];
let year = self._ymd[self.ystridx.unwrap()];
1 <= val && (val <= days_in_month(year, month).unwrap() as i32)
}
}
fn append(&mut self, val: i32, token: &str, label: Option<YMDLabel>) -> ParseResult<()> {
let mut label = label;
// Python auto-detects strings using the '__len__' function here.
// We instead take in both and handle as necessary.
if Decimal::from_str(token).is_ok() && token.len() > 2 {
self.century_specified = true;
match label {
None | Some(YMDLabel::Year) => label = Some(YMDLabel::Year),
Some(YMDLabel::Month) => {
return Err(ParseError::ImpossibleTimestamp("Invalid month"))
}
Some(YMDLabel::Day) => return Err(ParseError::ImpossibleTimestamp("Invalid day")),
}
}
if val > 100 {
self.century_specified = true;
match label {
None => label = Some(YMDLabel::Year),
Some(YMDLabel::Year) => (),
Some(YMDLabel::Month) => {
return Err(ParseError::ImpossibleTimestamp("Invalid month"))
}
Some(YMDLabel::Day) => return Err(ParseError::ImpossibleTimestamp("Invalid day")),
}
}
self._ymd.push(val);
match label {
Some(YMDLabel::Month) => {
if self.mstridx.is_some() {
Err(ParseError::YearMonthDayError("Month already set"))
} else {
self.mstridx = Some(self._ymd.len() - 1);
Ok(())
}
}
Some(YMDLabel::Day) => {
if self.dstridx.is_some() {
Err(ParseError::YearMonthDayError("Day already set"))
} else {
self.dstridx = Some(self._ymd.len() - 1);
Ok(())
}
}
Some(YMDLabel::Year) => {
if self.ystridx.is_some() {
Err(ParseError::YearMonthDayError("Year already set"))
} else {
self.ystridx = Some(self._ymd.len() - 1);
Ok(())
}
}
None => Ok(()),
}
}
fn resolve_from_stridxs(
&mut self,
strids: &mut HashMap<YMDLabel, usize>,
) -> ParseResult<(Option<i32>, Option<i32>, Option<i32>)> {
if self._ymd.len() == 3 && strids.len() == 2 {
let missing_key = if !strids.contains_key(&YMDLabel::Year) {
YMDLabel::Year
} else if !strids.contains_key(&YMDLabel::Month) {
YMDLabel::Month
} else {
YMDLabel::Day
};
let strids_vals: Vec<usize> = strids.values().cloned().collect();
let missing_val = if !strids_vals.contains(&0) {
0
} else if !strids_vals.contains(&1) {
1
} else {
2
};
strids.insert(missing_key, missing_val);
}
if self._ymd.len() != strids.len() {
return Err(ParseError::YearMonthDayError(
"Tried to resolve year, month, and day without enough information",
));
}
Ok((
strids.get(&YMDLabel::Year).map(|i| self._ymd[*i]),
strids.get(&YMDLabel::Month).map(|i| self._ymd[*i]),
strids.get(&YMDLabel::Day).map(|i| self._ymd[*i]),
))
}
#[allow(clippy::needless_return)]
fn resolve_ymd(
&mut self,
yearfirst: bool,
dayfirst: bool,
) -> ParseResult<(Option<i32>, Option<i32>, Option<i32>)> {
let len_ymd = self._ymd.len();
let mut strids: HashMap<YMDLabel, usize> = HashMap::new();
self.ystridx.map(|u| strids.insert(YMDLabel::Year, u));
self.mstridx.map(|u| strids.insert(YMDLabel::Month, u));
self.dstridx.map(|u| strids.insert(YMDLabel::Day, u));
// TODO: More Rustiomatic way of doing this?
if len_ymd == strids.len() && !strids.is_empty() || (len_ymd == 3 && strids.len() == 2) {
return self.resolve_from_stridxs(&mut strids);
};
// Received year, month, day, and ???
if len_ymd > 3 {
return Err(ParseError::YearMonthDayError(
"Received extra tokens in resolving year, month, and day",
));
}
match (len_ymd, self.mstridx) {
(1, Some(val)) | (2, Some(val)) => {
let other = if len_ymd == 1 {
self._ymd[0]
} else {
self._ymd[1 - val]
};
if other > 31 {
return Ok((Some(other), Some(self._ymd[val]), None));
}
return Ok((None, Some(self._ymd[val]), Some(other)));
}
(2, None) => {
if self._ymd[0] > 31 {
return Ok((Some(self._ymd[0]), Some(self._ymd[1]), None));
}
if self._ymd[1] > 31 {
return Ok((Some(self._ymd[1]), Some(self._ymd[0]), None));
}
if dayfirst && self._ymd[1] <= 12 {
return Ok((None, Some(self._ymd[1]), Some(self._ymd[0])));
}
return Ok((None, Some(self._ymd[0]), Some(self._ymd[1])));
}
(3, Some(0)) => {
if self._ymd[1] > 31 {
return Ok((Some(self._ymd[1]), Some(self._ymd[0]), Some(self._ymd[2])));
}
return Ok((Some(self._ymd[2]), Some(self._ymd[0]), Some(self._ymd[1])));
}
(3, Some(1)) => {
if self._ymd[0] > 31 || (yearfirst && self._ymd[2] <= 31) {
return Ok((Some(self._ymd[0]), Some(self._ymd[1]), Some(self._ymd[2])));
}
return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
}
(3, Some(2)) => {
// It was in the original docs, so: WTF!?
if self._ymd[1] > 31 {
return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
}
return Ok((Some(self._ymd[0]), Some(self._ymd[2]), Some(self._ymd[1])));
}
(3, None) => {
if self._ymd[0] > 31
|| self.ystridx == Some(0)
|| (yearfirst && self._ymd[1] <= 12 && self._ymd[2] <= 31)
{
if dayfirst && self._ymd[2] <= 12 {
return Ok((Some(self._ymd[0]), Some(self._ymd[2]), Some(self._ymd[1])));
}
return Ok((Some(self._ymd[0]), Some(self._ymd[1]), Some(self._ymd[2])));
} else if self._ymd[0] > 12 || (dayfirst && self._ymd[1] <= 12) {
return Ok((Some(self._ymd[2]), Some(self._ymd[1]), Some(self._ymd[0])));
}
return Ok((Some(self._ymd[2]), Some(self._ymd[0]), Some(self._ymd[1])));
}
(_, _) => {
return Ok((None, None, None));
}
}
}
}
#[derive(Default, Debug, PartialEq)]
struct ParsingResult {
year: Option<i32>,
month: Option<i32>,
day: Option<i32>,
weekday: Option<usize>,
hour: Option<i32>,
minute: Option<i32>,
second: Option<i32>,
nanosecond: Option<i64>,
tzname: Option<String>,
tzoffset: Option<i32>,
ampm: Option<bool>,
century_specified: bool,
any_unused_tokens: Vec<String>,
}
macro_rules! option_len {
($o:expr) => {{
if $o.is_some() {
1
} else {
0
}
}};
}
impl ParsingResult {
fn len(&self) -> usize {
option_len!(self.year)
+ option_len!(self.month)
+ option_len!(self.day)
+ option_len!(self.weekday)
+ option_len!(self.hour)
+ option_len!(self.minute)
+ option_len!(self.second)
+ option_len!(self.nanosecond)
+ option_len!(self.tzname)
+ option_len!(self.ampm)
}
}
/// Parser is responsible for doing the actual work of understanding a time string.
/// The root level `parse` function is responsible for constructing a default `Parser`
/// and triggering its behavior.
#[derive(Default)]
pub struct Parser {
info: ParserInfo,
}
impl Parser {
/// Create a new `Parser` instance using the provided `ParserInfo`.
///
/// This method allows you to set up a parser to handle different
/// names for days of the week, months, etc., enabling customization
/// for different languages or extra values.
pub fn new(info: ParserInfo) -> Self {
Parser { info }
}
/// Main method to trigger parsing of a string using the previously-provided
/// parser information. Returns a naive timestamp along with timezone and
/// unused tokens if available.
///
/// `dayfirst` and `yearfirst` force parser behavior in the event of ambiguous
/// dates. Consider the following scenarios where we parse the string '01.02.03'
///
/// - `dayfirst=Some(true)`, `yearfirst=None`: Results in `February 2, 2003`
/// - `dayfirst=None`, `yearfirst=Some(true)`: Results in `February 3, 2001`
/// - `dayfirst=Some(true)`, `yearfirst=Some(true)`: Results in `March 2, 2001`
///
/// `fuzzy` enables fuzzy parsing mode, allowing the parser to skip tokens if
/// they are unrecognized. However, the unused tokens will not be returned
/// unless `fuzzy_with_tokens` is set as `true`.
///
/// `default` is the timestamp used to infer missing values, and is midnight
/// of the current day by default. For example, when parsing the text '2003',
/// we will use the current month and day as a default value, leading to a
/// result of 'March 3, 2003' if the function was run using a default of
/// March 3rd.
///
/// `ignoretz` forces the parser to ignore timezone information even if it
/// is recognized in the time string
///
/// `tzinfos` is a map of timezone names to the offset seconds. For example,
/// the parser would ignore the 'EST' part of the string in '10 AM EST'
/// unless you added a `tzinfos` map of `{"EST": "14400"}`. Please note that
/// timezone name support (i.e. "EST", "BRST") is not available by default
/// at the moment, they must be added through `tzinfos` at the moment in
/// order to be resolved.
#[allow(clippy::too_many_arguments)]
pub fn parse(
&self,
timestr: &str,
dayfirst: Option<bool>,
yearfirst: Option<bool>,
fuzzy: bool,
fuzzy_with_tokens: bool,
default: Option<&NaiveDateTime>,
ignoretz: bool,
tzinfos: &HashMap<String, i32>,
) -> ParseResult<(NaiveDateTime, Option<FixedOffset>, Option<Vec<String>>)> {
let default_date = default.unwrap_or(&Local::now().naive_local()).date();
let default_ts = NaiveDateTime::new(default_date, NaiveTime::from_hms_opt(0, 0, 0).unwrap());
let (res, tokens) =
self.parse_with_tokens(timestr, dayfirst, yearfirst, fuzzy, fuzzy_with_tokens)?;
if res.len() == 0 {
return Err(ParseError::NoDate);
}
let naive = self.build_naive(&res, &default_ts)?;
if !ignoretz {
let offset = self.build_tzaware(&naive, &res, tzinfos)?;
Ok((naive, offset, tokens))
} else {
Ok((naive, None, tokens))
}
}
#[allow(clippy::cognitive_complexity)] // Imitating Python API is priority
fn parse_with_tokens(
&self,
timestr: &str,
dayfirst: Option<bool>,
yearfirst: Option<bool>,
fuzzy: bool,
fuzzy_with_tokens: bool,
) -> Result<(ParsingResult, Option<Vec<String>>), ParseError> {
let fuzzy = if fuzzy_with_tokens { true } else { fuzzy };
// This is probably a stylistic abomination
let dayfirst = if let Some(dayfirst) = dayfirst {
dayfirst
} else {
self.info.dayfirst
};
let yearfirst = if let Some(yearfirst) = yearfirst {
yearfirst
} else {
self.info.yearfirst
};
let mut res = ParsingResult::default();
let mut l = tokenize(&timestr);
let mut skipped_idxs: Vec<usize> = Vec::new();
let mut ymd = YMD::default();
let len_l = l.len();
let mut i = 0;
while i < len_l {
let value_repr = l[i].clone();
if let Ok(_v) = Decimal::from_str(&value_repr) {
i = self.parse_numeric_token(&l, i, &self.info, &mut ymd, &mut res, fuzzy)?;
} else if let Some(value) = self.info.weekday_index(&l[i]) {
res.weekday = Some(value);
} else if let Some(value) = self.info.month_index(&l[i]) {
ymd.append(value as i32, &l[i], Some(YMDLabel::Month))?;
if i + 1 < len_l {
if l[i + 1] == "-" || l[i + 1] == "/" {
// Jan-01[-99]
let sep = &l[i + 1];
// TODO: This seems like a very unsafe unwrap
ymd.append(l[i + 2].parse::<i32>()?, &l[i + 2], None)?;
if i + 3 < len_l && &l[i + 3] == sep {
// Jan-01-99
ymd.append(l[i + 4].parse::<i32>()?, &l[i + 4], None)?;
i += 2;
}
i += 2;
} else if i + 4 < len_l
&& l[i + 1] == l[i + 3]
&& l[i + 3] == " "
&& self.info.pertain_index(&l[i + 2])
{
// Jan of 01
if let Ok(value) = l[i + 4].parse::<i32>() {
let year = self.info.convertyear(value, false);
ymd.append(year, &l[i + 4], Some(YMDLabel::Year))?;
}
i += 4;
}
}
} else if let Some(value) = self.info.ampm_index(&l[i]) {
let is_ampm = self.ampm_valid(res.hour, res.ampm, fuzzy);
if is_ampm == Ok(true) {
res.hour = res.hour.map(|h| self.adjust_ampm(h, value));
res.ampm = Some(value);
} else if fuzzy {
skipped_idxs.push(i);
}
} else if self.could_be_tzname(res.hour, &res.tzname, res.tzoffset, &l[i]) {
res.tzname = Some(l[i].clone());
let tzname = res.tzname.clone().unwrap();
res.tzoffset = self.info.tzoffset_index(&tzname).map(|t| t as i32);
if i + 1 < len_l && (l[i + 1] == "+" || l[i + 1] == "-") {
// GMT+3
// According to dateutil docs - reverse the size, as GMT+3 means
// "my time +3 is GMT" not "GMT +3 is my time"
// TODO: Is there a better way of in-place modifying a vector?
let item = if l[i + 1] == "+" {
"-".to_owned()
} else {
"+".to_owned()
};
l[i + 1] = item;
res.tzoffset = None;
if self.info.utczone_index(&tzname) {
res.tzname = None;
}
}
} else if res.hour.is_some() && (l[i] == "+" || l[i] == "-") {
let signal = if l[i] == "+" { 1 } else { -1 };
let len_li = l[i].len();
let mut hour_offset: Option<i32> = None;
let mut min_offset: Option<i32> = None;
// TODO: check that l[i + 1] is integer?
if len_li == 4 {
// -0300
hour_offset = Some(l[i + 1][..2].parse::<i32>()?);
min_offset = Some(l[i + 1][2..4].parse::<i32>()?);
} else if i + 2 < len_l && l[i + 2] == ":" {
// -03:00
hour_offset = Some(l[i + 1].parse::<i32>()?);
min_offset = Some(l[i + 3].parse::<i32>()?);
i += 2;
} else if len_li <= 2 {
// -[0]3
let range_len = min(l[i + 1].len(), 2);
hour_offset = Some(l[i + 1][..range_len].parse::<i32>()?);
min_offset = Some(0);
}
res.tzoffset =
Some(signal * (hour_offset.unwrap() * 3600 + min_offset.unwrap() * 60));
let tzname = res.tzname.clone();
if i + 5 < len_l
&& self.info.jump_index(&l[i + 2])
&& l[i + 3] == "("
&& l[i + 5] == ")"
&& 3 <= l[i + 4].len()
&& self.could_be_tzname(res.hour, &tzname, None, &l[i + 4])
{
// (GMT)
res.tzname = Some(l[i + 4].clone());
i += 4;
}
i += 1;
} else if !(self.info.jump_index(&l[i]) || fuzzy) {
return Err(ParseError::UnrecognizedToken(l[i].clone()));
} else {
skipped_idxs.push(i);
}
i += 1;
}
let (year, month, day) = ymd.resolve_ymd(yearfirst, dayfirst)?;
res.century_specified = ymd.century_specified;
res.year = year;
res.month = month;
res.day = day;
if !self.info.validate(&mut res) {
Err(ParseError::UnrecognizedFormat)
} else if fuzzy_with_tokens {
let skipped_tokens = self.recombine_skipped(skipped_idxs, l);
Ok((res, Some(skipped_tokens)))
} else {
Ok((res, None))
}
}
fn could_be_tzname(
&self,
hour: Option<i32>,
tzname: &Option<String>,
tzoffset: Option<i32>,
token: &str,
) -> bool {
let all_ascii_upper = token
.chars()
.all(|c| 65u8 as char <= c && c <= 90u8 as char);
hour.is_some()
&& tzname.is_none()
&& tzoffset.is_none()
&& token.len() <= 5
&& (all_ascii_upper || self.info.utczone.contains_key(token))
}
#[allow(clippy::unnecessary_unwrap)]
fn ampm_valid(&self, hour: Option<i32>, ampm: Option<bool>, fuzzy: bool) -> ParseResult<bool> {
let mut val_is_ampm = !(fuzzy && ampm.is_some());
if hour.is_none() {
if fuzzy {
val_is_ampm = false;
} else {
return Err(ParseError::AmPmWithoutHour);
}
} else if !(0 <= hour.unwrap() && hour.unwrap() <= 12) {
if fuzzy {
val_is_ampm = false;
} else {
return Err(ParseError::ImpossibleTimestamp("Invalid hour"));
}
}
Ok(val_is_ampm)
}
fn build_naive(
&self,
res: &ParsingResult,
default: &NaiveDateTime,
) -> ParseResult<NaiveDateTime> {
let y = res.year.unwrap_or_else(|| default.year());
let m = res.month.unwrap_or_else(|| default.month() as i32) as u32;
let d_offset = if res.weekday.is_some() && res.day.is_none() {
let dow = day_of_week(y as u32, m, default.day())?;
// UNWRAP: We've already check res.weekday() is some
let actual_weekday = (res.weekday.unwrap() + 1) % 7;
let other = DayOfWeek::from_numeral(actual_weekday as u32);
Duration::days(i64::from(dow.difference(&other)))
} else {
Duration::days(0)
};
// TODO: Change month/day to u32
let d = NaiveDate::from_ymd_opt(
y,
m,
min(
res.day.unwrap_or(default.day() as i32) as u32,
days_in_month(y, m as i32)?,
),
)
.ok_or_else(|| ParseError::ImpossibleTimestamp("Invalid date range given"))?;
let d = d + d_offset;
let hour = res.hour.unwrap_or(default.hour() as i32) as u32;
let minute = res.minute.unwrap_or(default.minute() as i32) as u32;
let second = res.second.unwrap_or(default.second() as i32) as u32;
let nanosecond = res
.nanosecond
.unwrap_or(default.timestamp_subsec_nanos() as i64) as u32;
let t =
NaiveTime::from_hms_nano_opt(hour, minute, second, nanosecond).ok_or_else(|| {
if hour >= 24 {
ParseError::ImpossibleTimestamp("Invalid hour")
} else if minute >= 60 {
ParseError::ImpossibleTimestamp("Invalid minute")
} else if second >= 60 {
ParseError::ImpossibleTimestamp("Invalid second")
} else if nanosecond >= 2_000_000_000 {
ParseError::ImpossibleTimestamp("Invalid microsecond")
} else {
unreachable!();
}
})?;
Ok(NaiveDateTime::new(d, t))
}
fn build_tzaware(
&self,
_dt: &NaiveDateTime,
res: &ParsingResult,
tzinfos: &HashMap<String, i32>,
) -> ParseResult<Option<FixedOffset>> {
if let Some(offset) = res.tzoffset {
Ok(FixedOffset::east_opt(offset))
} else if res.tzoffset == None
&& (res.tzname == Some(" ".to_owned())
|| res.tzname == Some(".".to_owned())
|| res.tzname == Some("-".to_owned())
|| res.tzname == None)
{
Ok(None)
} else if res.tzname.is_some() && tzinfos.contains_key(res.tzname.as_ref().unwrap()) {
Ok(FixedOffset::east_opt(
*tzinfos.get(res.tzname.as_ref().unwrap()).unwrap(),
))
} else if let Some(tzname) = res.tzname.as_ref() {
println!("tzname {} identified but not understood.", tzname);
Ok(None)
} else {
Err(ParseError::TimezoneUnsupported)
}
}
#[allow(clippy::unnecessary_unwrap)]
fn parse_numeric_token(
&self,
tokens: &[String],
idx: usize,
info: &ParserInfo,
ymd: &mut YMD,
res: &mut ParsingResult,
fuzzy: bool,
) -> ParseResult<usize> {
let mut idx = idx;
let value_repr = &tokens[idx];
let mut value = Decimal::from_str(&value_repr).unwrap();
let len_li = value_repr.len();
let len_l = tokens.len();
// TODO: I miss the `x in y` syntax
// TODO: Decompose this logic a bit
if ymd.len() == 3
&& (len_li == 2 || len_li == 4)
&& res.hour.is_none()
&& (idx + 1 >= len_l
|| (tokens[idx + 1] != ":" && info.hms_index(&tokens[idx + 1]).is_none()))
{
// 1990101T32[59]
let s = &tokens[idx];
res.hour = s[0..2].parse::<i32>().ok();
if len_li == 4 {
res.minute = Some(s[2..4].parse::<i32>()?)
}
} else if len_li == 6 || (len_li > 6 && tokens[idx].find('.') == Some(6)) {
// YYMMDD or HHMMSS[.ss]
let s = &tokens[idx];
if ymd.len() == 0 && tokens[idx].find('.') == None {
ymd.append(s[0..2].parse::<i32>()?, &s[0..2], None)?;
ymd.append(s[2..4].parse::<i32>()?, &s[2..4], None)?;
ymd.append(s[4..6].parse::<i32>()?, &s[4..6], None)?;
} else {
// 19990101T235959[.59]
res.hour = s[0..2].parse::<i32>().ok();
res.minute = s[2..4].parse::<i32>().ok();
let t = self.parsems(&s[4..])?;
res.second = Some(t.0);
res.nanosecond = Some(t.1);
}
} else if vec![8, 12, 14].contains(&len_li) {
// YYMMDD
let s = &tokens[idx];
ymd.append(s[..4].parse::<i32>()?, &s[..4], Some(YMDLabel::Year))?;
ymd.append(s[4..6].parse::<i32>()?, &s[4..6], None)?;
ymd.append(s[6..8].parse::<i32>()?, &s[6..8], None)?;
if len_li > 8 {
res.hour = Some(s[8..10].parse::<i32>()?);
res.minute = Some(s[10..12].parse::<i32>()?);
if len_li > 12 {
res.second = Some(s[12..].parse::<i32>()?);
}
}
} else if let Some(hms_idx) = self.find_hms_index(idx, tokens, info, true) {
// HH[ ]h or MM[ ]m or SS[.ss][ ]s
let (new_idx, hms) = self.parse_hms(idx, tokens, info, Some(hms_idx));
if let Some(hms) = hms {
self.assign_hms(res, value_repr, hms)?;
}
idx = new_idx;
} else if idx + 2 < len_l && tokens[idx + 1] == ":" {
// HH:MM[:SS[.ss]]
// TODO: Better story around Decimal handling
res.hour = Some(value.floor().to_i64().unwrap() as i32);
// TODO: Rescope `value` here?
value = self.to_decimal(&tokens[idx + 2])?;
let min_sec = self.parse_min_sec(value);
res.minute = Some(min_sec.0);
res.second = min_sec.1;
if idx + 4 < len_l && tokens[idx + 3] == ":" {
// TODO: (x, y) = (a, b) syntax?
let ms = self.parsems(&tokens[idx + 4]).unwrap();
res.second = Some(ms.0);
res.nanosecond = Some(ms.1);
idx += 2;
}
idx += 2;
} else if idx + 1 < len_l
&& (tokens[idx + 1] == "-" || tokens[idx + 1] == "/" || tokens[idx + 1] == ".")
{
// TODO: There's got to be a better way of handling the condition above
let sep = &tokens[idx + 1];
ymd.append(value_repr.parse::<i32>()?, &value_repr, None)?;
if idx + 2 < len_l && !info.jump_index(&tokens[idx + 2]) {
if let Ok(val) = tokens[idx + 2].parse::<i32>() {
ymd.append(val, &tokens[idx + 2], None)?;
} else if let Some(val) = info.month_index(&tokens[idx + 2]) {
ymd.append(val as i32, &tokens[idx + 2], Some(YMDLabel::Month))?;
}
if idx + 3 < len_l && &tokens[idx + 3] == sep {
if let Some(value) = info.month_index(&tokens[idx + 4]) {
ymd.append(value as i32, &tokens[idx + 4], Some(YMDLabel::Month))?;
} else if let Ok(val) = tokens[idx + 4].parse::<i32>() {
ymd.append(val, &tokens[idx + 4], None)?;
} else {
return Err(ParseError::UnrecognizedFormat);
}
idx += 2;
}
idx += 1;
}
idx += 1
} else if idx + 1 >= len_l || info.jump_index(&tokens[idx + 1]) {
if idx + 2 < len_l && info.ampm_index(&tokens[idx + 2]).is_some() {
let hour = value.to_i64().unwrap() as i32;
let ampm = info.ampm_index(&tokens[idx + 2]).unwrap();
res.hour = Some(self.adjust_ampm(hour, ampm));
idx += 1;
} else {
//let value = value.floor().to_i32().ok_or(Err(ParseError::InvalidNumeric()))
let value = value.floor().to_i32().ok_or_else(|| ParseError::InvalidNumeric(value_repr.to_owned()))?;
ymd.append(value, &value_repr, None)?;
}
idx += 1;
} else if info.ampm_index(&tokens[idx + 1]).is_some()
&& (*ZERO <= value && value < *TWENTY_FOUR)
{
// 12am
let hour = value.to_i64().unwrap() as i32;
res.hour = Some(self.adjust_ampm(hour, info.ampm_index(&tokens[idx + 1]).unwrap()));
idx += 1;
} else if ymd.could_be_day(value.to_i64().unwrap() as i32) {
ymd.append(value.to_i64().unwrap() as i32, &value_repr, None)?;
} else if !fuzzy {
return Err(ParseError::UnrecognizedFormat);
}
Ok(idx)
}
fn adjust_ampm(&self, hour: i32, ampm: bool) -> i32 {
if hour < 12 && ampm {
hour + 12
} else if hour == 12 && !ampm {
0
} else {
hour
}
}
fn parsems(&self, seconds_str: &str) -> ParseResult<(i32, i64)> {
if seconds_str.contains('.') {
let split: Vec<&str> = seconds_str.split('.').collect();
let (i, f): (&str, &str) = (split[0], split[1]);
let i_parse = i.parse::<i32>()?;
let f_parse = ljust(f, 9, '0').parse::<i64>()?;
Ok((i_parse, f_parse))
} else {
Ok((seconds_str.parse::<i32>()?, 0))
}
}
fn find_hms_index(
&self,
idx: usize,
tokens: &[String],
info: &ParserInfo,
allow_jump: bool,
) -> Option<usize> {
let len_l = tokens.len();
let mut hms_idx = None;
// There's a super weird edge case that can happen
// because Python safely handles negative array indices,
// and Rust (because of usize) does not.
let idx_minus_two = if idx == 1 && len_l > 0 {
len_l - 1
} else if idx == 0 && len_l > 1 {
len_l - 2
} else if idx > 1 {
idx - 2
} else if len_l == 0 {
panic!("Attempting to find_hms_index() wih no tokens.");
} else {
0
};
if idx + 1 < len_l && info.hms_index(&tokens[idx + 1]).is_some() {
hms_idx = Some(idx + 1)
} else if allow_jump
&& idx + 2 < len_l
&& tokens[idx + 1] == " "
&& info.hms_index(&tokens[idx + 2]).is_some()
{
hms_idx = Some(idx + 2)
} else if idx > 0 && info.hms_index(&tokens[idx - 1]).is_some() {
hms_idx = Some(idx - 1)
} else if len_l > 0
&& idx > 0
&& idx == len_l - 1
&& tokens[idx - 1] == " "
&& info.hms_index(&tokens[idx_minus_two]).is_some()
{
hms_idx = Some(idx - 2)
}
hms_idx
}
#[allow(clippy::unnecessary_unwrap)]
fn parse_hms(
&self,
idx: usize,
tokens: &[String],
info: &ParserInfo,
hms_index: Option<usize>,
) -> (usize, Option<usize>) {
if hms_index.is_none() {
(idx, None)
} else if hms_index.unwrap() > idx {
(
hms_index.unwrap(),
info.hms_index(&tokens[hms_index.unwrap()]),
)
} else {
(
idx,
info.hms_index(&tokens[hms_index.unwrap()]).map(|u| u + 1),
)
}
}
fn assign_hms(&self, res: &mut ParsingResult, value_repr: &str, hms: usize) -> ParseResult<()> {
let value = self.to_decimal(value_repr)?;
if hms == 0 {
res.hour = value.to_i32();
if !close_to_integer(&value) {
res.minute = Some((*SIXTY * (value % *ONE)).to_i64().unwrap() as i32);
}
} else if hms == 1 {
let (min, sec) = self.parse_min_sec(value);
res.minute = Some(min);
res.second = sec;
} else if hms == 2 {
let (sec, micro) = self.parsems(value_repr).unwrap();
res.second = Some(sec);
res.nanosecond = Some(micro);
}
Ok(())
}
fn to_decimal(&self, value: &str) -> ParseResult<Decimal> {
Decimal::from_str(value).or_else(|_| Err(ParseError::InvalidNumeric(value.to_owned())))
}
fn parse_min_sec(&self, value: Decimal) -> (i32, Option<i32>) {
// UNWRAP: i64 guaranteed to be fine because of preceding floor
let minute = value.floor().to_i64().unwrap() as i32;
let mut second = None;
let sec_remainder = value - value.floor();
if sec_remainder != *ZERO {
second = Some((*SIXTY * sec_remainder).floor().to_i64().unwrap() as i32);
}
(minute, second)
}
fn recombine_skipped(&self, skipped_idxs: Vec<usize>, tokens: Vec<String>) -> Vec<String> {
let mut skipped_tokens: Vec<String> = vec![];
let mut sorted_idxs = skipped_idxs.clone();
sorted_idxs.sort();
for (i, idx) in sorted_idxs.iter().enumerate() {
if i > 0 && idx - 1 == skipped_idxs[i - 1] {
// UNWRAP: Having an initial value and unconditional push at end guarantees value
let mut t = skipped_tokens.pop().unwrap();
t.push_str(tokens[*idx].as_ref());
skipped_tokens.push(t);
} else {
skipped_tokens.push(tokens[*idx].to_owned());
}
}
skipped_tokens
}
}
fn close_to_integer(value: &Decimal) -> bool {
value % *ONE == *ZERO
}
fn ljust(s: &str, chars: usize, replace: char) -> String {
if s.len() >= chars {
s[..chars].to_owned()
} else {
format!("{}{}", s, replace.to_string().repeat(chars - s.len()))
}
}
/// Main entry point for using `dtparse`. The parse function is responsible for
/// taking in a string representing some time value, and turning it into
/// a timestamp with optional timezone information if it can be identified.
///
/// The default implementation assumes English values for names of months,
/// days of the week, etc. It is equivalent to Python's `dateutil.parser.parse()`
pub fn parse(timestr: &str) -> ParseResult<(NaiveDateTime, Option<FixedOffset>)> {
let res = DEFAULT_PARSER.parse(
timestr,
None,
None,
false,
false,
None,
false,
&HashMap::new(),
)?;
Ok((res.0, res.1))
}
Reference in New Issue View Git Blame Copy Permalink