Parse Zulu suffix with %z?

[MarcoGorelli]

The following runs fine:

use chrono::{DateTime};

fn main() {
    let parse_from_str = DateTime::parse_from_str;
    let ts = "2000-01-01T01:23+01:00";
    let fmt = "%Y-%m-%dT%H:%M%z";
    let parsed = parse_from_str(ts, fmt);
    println!("{:?}", parsed);
}

and returns

Ok(2000-01-01T01:23:00+01:00)

However, if I instead put

let ts = "2000-01-01T01:23Z";

then it fails:

Err(ParseError(Invalid))

By contrast, in Python, I can parse that string using this format:

In [1]: import datetime as dt

In [2]: dt.datetime.strptime("2000-01-01T01:23Z", "%Y-%m-%dT%H:%M%z")
Out[2]: datetime.datetime(2000, 1, 1, 1, 23, 0, tzinfo=datetime.timezone.utc)

Should parse_from_str be able to parse the Zulu suffix 'Z' with '%z'?

(note: this question was originally posted on StackOverflow, and it was suggested to report it here)

[djc]

I don't have a strong opinion on this myself. So my questions would be around, what other platforms/libraries (like Python) accept Z as %z? What about the Unix date command? PHP/Ruby/Go/Java/C libraries? The Rust time crate? If this is usually accepted I think it probably makes sense to allow it in chrono, too.

[MarcoGorelli]

Thanks for your reply!

• Unix date: looks like it

  $ date -d "2023-01-30T10:30Z" "+%Y-%m-%dT%H:%M%z"
  2023-01-30T10:30+0000

• R lubridate: also yes

  > timestring <- c(
    "2000-01-02T13:00Z"
  )
  lubridate::parse_date_time(timestring, c("%Y-%m-%dT%H:%M%z"), exact=TRUE)
  [1] "2000-01-02 13:00:00 UTC"

I don't know the other languages listed (the closest I get to C is Cython), once I've figured out how to install them and which libraries to use I'll get back to you

[35VLG84]

This is slightly off topic for %z support, but as your example is for parsing ISO 8601 timestamps, here is a recipe how to parse ISO 8601 timestamps without knowing exact precision or offset syntax:

use chrono::prelude::*;

fn main() {
    println!("{:?}", "2023-02-12T14:15:16Z".parse::<DateTime<FixedOffset>>());
    println!("{:?}", "2023-02-12T14:15:16+02:00".parse::<DateTime<FixedOffset>>());
    println!("{:?}", "2023-02-12T14:15:16.123456789Z".parse::<DateTime<FixedOffset>>());
    println!("{:?}", "2023-02-12T14:15:16.123456789+02:00".parse::<DateTime<FixedOffset>>());
}

This will print:

Ok(2023-02-12T14:15:16+00:00)
Ok(2023-02-12T14:15:16+02:00)
Ok(2023-02-12T14:15:16.123456789+00:00)
Ok(2023-02-12T14:15:16.123456789+02:00)

I stumbled into the same problem, while porting Java ZonedDateTime stuff to Rust. And was basically banging my head against wall with this until I figured out the FromStr trait and parse.

[MarcoGorelli]

I just checked, and '%#z' actually parses it fine:

use chrono::{DateTime};

fn main() {
    let parse_from_str = DateTime::parse_from_str;
    let ts = "2000-01-01T01:23Z";
    let fmt = "%Y-%m-%dT%H:%M%#z";
    let parsed = parse_from_str(ts, fmt);
    println!("{:?}", parsed);
}

The docs say

Parsing only: Same as %z but allows minutes to be missing or present.

Given that '%#z' parses Z, should '%z' parse it too?

[MarcoGorelli]

Given that '%#z' parses Z, should '%z' parse it too?

@djc if this seems reasonable to you I'll try putting together a PR

[djc]

Yes, that seems reasonable, looking forward to your PR!

[Crypto-Spartan]

Any updates to this?

[djc]

No -- if there were, you'd see some comments here.