How can i get timestamp_micros like:

https://docs.rs/chrono/latest/chrono/struct.DateTime.html#method.timestamp_micros

we need small unit for timestamp.

You are advised to optimize format performance this change Can improve format performance several times

for example: this code

write!(f, "{:04}-{:02}-{:02}", self.year, self.month, self.day)

to My Code

impl Display for LogDate {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
       let mut buf: [u8; 29] = *b"0000-00-00 00:00:00.000000000";

        buf[0] = b'0' + (self.year / 1000) as u8;
        buf[1] = b'0' + (self.year / 100 % 10) as u8;
        buf[2] = b'0' + (self.year / 10 % 10) as u8;
        buf[3] = b'0' + (self.year % 10) as u8;


        buf[5] = b'0' + (self.mon / 10) as u8;
        buf[6] = b'0' + (self.mon % 10) as u8;

        buf[8] = b'0' + (self.day / 10) as u8;
        buf[9] = b'0' + (self.day % 10) as u8;

        buf[11] = b'0' + (self.hour / 10) as u8;
        buf[12] = b'0' + (self.hour % 10) as u8;
        buf[14] = b'0' + (self.min / 10) as u8;
        buf[15] = b'0' + (self.min % 10) as u8;
        buf[17] = b'0' + (self.sec / 10) as u8;
        buf[18] = b'0' + (self.sec % 10) as u8;

        buf[19] = b'.';

        buf[20] = b'0' + (self.nano / 100000000) as u8;
        buf[21] = b'0' + (self.nano / 10000000 % 10) as u8;
        buf[22] = b'0' + (self.nano / 1000000 % 10) as u8;
        buf[23] = b'0' + (self.nano / 100000 % 10) as u8;
        buf[24] = b'0' + (self.nano / 10000 % 10) as u8;
        buf[25] = b'0' + (self.nano / 1000 % 10) as u8;
        buf[26] = b'0' + (self.nano / 100 % 10) as u8;
        buf[27] = b'0' + (self.nano / 10 % 10) as u8;
        buf[28] = b'0' + (self.nano % 10) as u8;

        f.write_str(std::str::from_utf8(&buf[..]).unwrap())
    }
}

impl for #16 I think the time is also important to the performance of the Format string, such as crates the httpdate, It directly affects HTTP Web framework performance

• bench code impl

#[bench]
fn bench_format_date(bench: &mut Bencher) {
    let date = Date{
        year: 2022,
        month: 7,
        day: 10
    };
    bench.iter(|| {
        date.to_string();
    })
}

#[bench]
fn bench_format_time(bench: &mut Bencher) {
    let time = Time{
        hour: 10,
        minute: 11,
        second: 12,
        microsecond: 11
    };
    bench.iter(|| {
        time.to_string();
    })
}

#[bench]
fn bench_format_date_time(bench: &mut Bencher) {
    let date = DateTime{
        date: Date {
            year: 2022,
            month: 7,
            day: 10
        },
        time: Time {
            hour: 0,
            minute: 0,
            second: 0,
            microsecond: 0
        },
        offset: Some(60)
    };
    bench.iter(|| {
        date.to_string();
    })
}

• befor change

test bench_format_date               ... bench:         149 ns/iter (+/- 3)
test bench_format_time               ... bench:         231 ns/iter (+/- 4)
test bench_format_date_time          ... bench:         283 ns/iter (+/- 3) //offset None
test bench_format_date_time          ... bench:         326 ns/iter (+/- 6) //offset Some(60)

• after change

test bench_format_date               ... bench:          51 ns/iter (+/- 0)
test bench_format_time               ... bench:          53 ns/iter (+/- 3)
test bench_format_date_time          ... bench:          50 ns/iter (+/- 0) //offset None
test bench_format_date_time          ... bench:         115 ns/iter (+/- 0) //offset Some(60)

The DateTime format will affect about 50ns due to offset, because it is divided twice of Memory allocation

f.write_str(std::str::from_utf8(&buf[..]).unwrap())?;

so.If I can fix the DateTime format string length to Fixed length, then this performance can be improved to 50ns/iter

Hi, Tom from Codecov here. I saw the tweet you posted earlier about having issues with Codecov, and I just wanted to reach out and see what we could do to help here.

the test is failed. but in python is ok

let d7 = Duration::new(false, 3, 0, 0);
let d8 = Duration::new(false, 4, 0, 0);
assert!(d7 > d8);
assert!(d8 < d7);

In [3]: timedelta(days=-3) > timedelta(days=-4)
Out[3]: True

fix #6

To check:

• not sure the timezone comparison is right if the date/time is different
• maybe we need to support naive vs. non-naive comparison for pydantic?

Add the following datetime formats:

• ISO8601, e.g P1Y2M3DT4H5M6S
• time formats, e.g. 12:13:14.56
• time formats prefixed with day(s), e.g. 2 days 12:13:14

Using SystemTime.

Only tricky question is how we get timezone, perhaps we make it an argument to now(), and I guess also to today() since "today in London != today in Syndey"

Tried a custom iterator, but in the end it's even faster if we remove the iterator and count byte positions manually.

By f657cd3 there's a good custom iterator which is already significantly faster.

Having a way to convert into std::time structs would help, e.g.

impl From<DateTime> for std::time::SystemTime { ...}
impl From<&DateTime> for std::time::SystemTime { ...}
impl From<Duration> for std::time::Duration { ...}
impl From<&Duration> for std::time::Duration {...}

Better support for the Proleptic Gregorian calendar for timestamps.

Basically go back before 1600 to 0 BCE.

Doubt many people will need this, but technically I think it would be correct.

Again to match python better and allow times with timezones.

My mistake, didn't notice python times can have timezones.

Should also rename to tz_offset to be more explicit.