python-dateutil-rs 0.1.2__tar.gz → 0.1.3__tar.gz

{python_dateutil_rs-0.1.2 → python_dateutil_rs-0.1.3}/Cargo.lock

@@ -220,7 +220,7 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "dateutil"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "bitflags",
  "chrono",
@@ -234,7 +234,7 @@ dependencies = [
 
 [[package]]
 name = "dateutil-py"
-version = "0.1.2"
+version = "0.1.3"
 dependencies = [
  "chrono",
  "dateutil",

{python_dateutil_rs-0.1.2 → python_dateutil_rs-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-dateutil-rs
-Version: 0.1.2
+Version: 0.1.3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{python_dateutil_rs-0.1.2 → python_dateutil_rs-0.1.3}/crates/dateutil-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dateutil"
-version = "0.1.2"
+version = "0.1.3"
 edition = "2021"
 license = "MIT"
 description = "Fast date utility library — parser, relativedelta, rrule, timezone (Rust reimplementation of python-dateutil)"

python_dateutil_rs-0.1.3/crates/dateutil-core/README.md

@@ -0,0 +1,167 @@
+# dateutil
+
+[![Crates.io](https://img.shields.io/crates/v/dateutil.svg?style=flat-square)](https://crates.io/crates/dateutil)
+[![docs.rs](https://img.shields.io/docsrs/dateutil?style=flat-square)](https://docs.rs/dateutil)
+[![License](https://img.shields.io/crates/l/dateutil.svg?style=flat-square)](https://crates.io/crates/dateutil)
+[![CI](https://github.com/wakita181009/dateutil-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/wakita181009/dateutil-rs/actions/workflows/ci.yml)
+
+Fast date utility library for Rust — parser, relativedelta, rrule, timezone.
+
+A performance-focused Rust reimplementation of [python-dateutil](https://github.com/dateutil/dateutil), designed for native Rust usage. Also available as a Python package ([python-dateutil-rs](https://pypi.org/project/python-dateutil-rs/)) via PyO3.
+
+## Features
+
+- **Parser** — Parse human-readable date strings with a zero-copy tokenizer and PHF lookup tables
+- **ISO 8601** — Strict ISO-8601 parsing via `isoparse()`
+- **RelativeDelta** — Relative date arithmetic (months, years, weekdays, etc.)
+- **RRule / RRuleSet** — RFC 5545 recurrence rules with bitflag filters and buffer-reusing iteration
+- **Timezone** — `gettz()` with TZif file support, DST handling, and process-lifetime caching
+- **Easter** — Easter date calculation (Julian, Orthodox, Western)
+- **Weekday** — `MO`–`SU` constants with N-th occurrence support
+
+## Installation
+
+```toml
+[dependencies]
+dateutil = "0.1"
+```
+
+## Quick Start
+
+### Parsing date strings
+
+```rust
+use chrono::NaiveDate;
+use dateutil::parser;
+
+// Parse a human-readable date string
+let dt = parser::parse("January 15, 2026 10:30 AM", None, None, false)
+    .unwrap();
+assert_eq!(dt.date(), NaiveDate::from_ymd_opt(2026, 1, 15).unwrap());
+
+// ISO-8601 strict parsing
+use dateutil::parser::isoparser::isoparse;
+let dt = isoparse("2026-01-15T10:30:00").unwrap();
+```
+
+### Relative deltas
+
+```rust
+use chrono::{NaiveDate, NaiveDateTime};
+use dateutil::relativedelta::RelativeDelta;
+
+let dt = NaiveDate::from_ymd_opt(2026, 1, 31).unwrap().and_hms_opt(0, 0, 0).unwrap();
+let rd = RelativeDelta::new().months(1).build();
+
+// Jan 31 + 1 month = Feb 28 (clamped)
+let result = rd.add_to_datetime(dt);
+assert_eq!(result.date(), NaiveDate::from_ymd_opt(2026, 2, 28).unwrap());
+```
+
+### Recurrence rules
+
+```rust
+use chrono::NaiveDate;
+use dateutil::rrule::{Frequency, Recurrence, RRuleBuilder};
+
+let dtstart = NaiveDate::from_ymd_opt(2026, 1, 1).unwrap()
+    .and_hms_opt(0, 0, 0).unwrap();
+
+let rule = RRuleBuilder::new(Frequency::Monthly)
+    .dtstart(dtstart)
+    .count(3)
+    .build()
+    .unwrap();
+
+let dates = rule.all();
+assert_eq!(dates.len(), 3);
+
+// Also works as an iterator
+for dt in rule.iter().take(3) {
+    println!("{}", dt);
+}
+```
+
+### Parsing RFC 5545 RRULE strings
+
+```rust
+use dateutil::rrule::parse::rrulestr;
+
+let result = rrulestr(
+    "DTSTART:20260101T000000\nRRULE:FREQ=WEEKLY;COUNT=4;BYDAY=MO,WE,FR",
+    false,
+).unwrap();
+```
+
+### Timezones
+
+```rust
+use chrono::NaiveDate;
+use dateutil::tz::{self, TzOps};
+
+// Look up an IANA timezone (cached after first call)
+let tz = tz::gettz(Some("America/New_York")).unwrap();
+
+let dt = NaiveDate::from_ymd_opt(2026, 7, 15).unwrap()
+    .and_hms_opt(12, 0, 0).unwrap();
+
+// UTC offset in seconds (EDT = -4h)
+assert_eq!(tz.utcoffset(dt, false), -4 * 3600);
+
+// DST gap/overlap utilities
+assert!(tz::datetime_exists(dt, &tz));
+assert!(!tz::datetime_ambiguous(dt, &tz));
+```
+
+### Easter
+
+```rust
+use chrono::NaiveDate;
+use dateutil::easter::{easter, EasterMethod};
+
+let date = easter(2026, EasterMethod::Western).unwrap();
+assert_eq!(date, NaiveDate::from_ymd_opt(2026, 4, 5).unwrap());
+```
+
+### Weekday constants
+
+```rust
+use dateutil::common::{MO, TU, FR};
+
+// N-th occurrence (e.g., 2nd Tuesday)
+let second_tue = TU.nth(2);
+assert_eq!(second_tue.n(), Some(2));
+```
+
+## Modules
+
+| Module | Description |
+|--------|-------------|
+| `dateutil::parser` | Date string parsing (`parse`, `isoparse`, `parse_to_result`) |
+| `dateutil::relativedelta` | Relative date arithmetic (`RelativeDelta`, `RelativeDeltaBuilder`) |
+| `dateutil::rrule` | RFC 5545 recurrence rules (`RRule`, `RRuleBuilder`, `Recurrence`) |
+| `dateutil::rrule::set` | Recurrence rule sets (`RRuleSet`) |
+| `dateutil::rrule::parse` | RRULE string parsing (`rrulestr`) |
+| `dateutil::tz` | Timezones (`gettz`, `TzOps`, `TimeZone`, `TzFile`, `TzOffset`, `TzUtc`, `TzLocal`) |
+| `dateutil::easter` | Easter calculation (`easter`, `EasterMethod`) |
+| `dateutil::common` | Weekday constants (`MO`–`SU`, `Weekday`) |
+| `dateutil::error` | Error types (`ParseError`, `RRuleError`, `TzError`, etc.) |
+
+## Performance
+
+Benchmarked against python-dateutil (via PyO3 bindings):
+
+| Module | Speedup |
+|--------|---------|
+| Parser (parse) | 19.5x–36.0x |
+| Parser (isoparse) | 13.0x–38.4x |
+| RRule | 5.9x–63.7x |
+| Timezone | 1.0x–896.7x |
+| RelativeDelta | 2.0x–28.1x |
+| Easter | 5.0x–7.3x |
+
+Key optimizations: zero-copy tokenizer, PHF compile-time hash tables, bitflag-based filters, `SmallVec` buffer reuse, `FxHashMap` timezone cache, `TzOps` trait for generic zero-clone dispatch.
+
+## License
+
+[MIT](../../LICENSE)

{python_dateutil_rs-0.1.2 → python_dateutil_rs-0.1.3}/crates/dateutil-core/benches/benchmarks.rs

@@ -1,14 +1,14 @@
-use criterion::{criterion_group, criterion_main, Criterion};
-use std::hint::black_box;
 use chrono::NaiveDate;
+use criterion::{criterion_group, criterion_main, Criterion};
 use dateutil::common::Weekday;
 use dateutil::easter::{easter, EasterMethod};
 use dateutil::parser;
 use dateutil::parser::tokenizer;
 use dateutil::relativedelta::RelativeDelta;
-use dateutil::rrule::{Frequency, Recurrence, RRuleBuilder};
 use dateutil::rrule::parse::rrulestr;
 use dateutil::rrule::set::RRuleSet;
+use dateutil::rrule::{Frequency, RRuleBuilder, Recurrence};
+use std::hint::black_box;
 
 fn bench_tokenizer(c: &mut Criterion) {
     c.bench_function("tokenize_simple_date", |b| {
@@ -47,21 +47,31 @@ fn bench_parser(c: &mut Criterion) {
 
     c.bench_function("parse_datetime", |b| {
         b.iter(|| {
-            black_box(parser::parse(black_box("2024-01-15 10:30:45"), false, false, None, None).unwrap());
+            black_box(
+                parser::parse(black_box("2024-01-15 10:30:45"), false, false, None, None).unwrap(),
+            );
         })
     });
 
     c.bench_function("parse_month_name", |b| {
         b.iter(|| {
-            black_box(parser::parse(black_box("January 15, 2024"), false, false, None, None).unwrap());
+            black_box(
+                parser::parse(black_box("January 15, 2024"), false, false, None, None).unwrap(),
+            );
         })
     });
 
     c.bench_function("parse_complex", |b| {
         b.iter(|| {
             black_box(
-                parser::parse(black_box("Monday, January 15, 2024 3:30:45.123456 PM UTC"), false, false, None, None)
-                    .unwrap(),
+                parser::parse(
+                    black_box("Monday, January 15, 2024 3:30:45.123456 PM UTC"),
+                    false,
+                    false,
+                    None,
+                    None,
+                )
+                .unwrap(),
             );
         })
     });
@@ -71,8 +81,11 @@ fn bench_parser(c: &mut Criterion) {
             black_box(
                 parser::parse_to_result(
                     black_box("Monday, January 15, 2024 3:30:45.123456 PM EST -05:00"),
-                    false, false, None,
-                ).unwrap(),
+                    false,
+                    false,
+                    None,
+                )
+                .unwrap(),
             );
         })
     });
@@ -97,7 +110,16 @@ fn bench_parser(c: &mut Criterion) {
 
     c.bench_function("parse_ampm", |b| {
         b.iter(|| {
-            black_box(parser::parse(black_box("January 15, 2024 3:30 PM"), false, false, None, None).unwrap());
+            black_box(
+                parser::parse(
+                    black_box("January 15, 2024 3:30 PM"),
+                    false,
+                    false,
+                    None,
+                    None,
+                )
+                .unwrap(),
+            );
         })
     });
 
@@ -203,8 +225,13 @@ fn bench_relativedelta(c: &mut Criterion) {
     c.bench_function("relativedelta_add_complex", |b| {
         let wd = Weekday::new(4, Some(2)).unwrap();
         let delta = RelativeDelta::builder()
-            .years(1).months(2).days(3)
-            .hours(4).minutes(30).seconds(15).microseconds(500_000)
+            .years(1)
+            .months(2)
+            .days(3)
+            .hours(4)
+            .minutes(30)
+            .seconds(15)
+            .microseconds(500_000)
             .weekday(wd)
             .build()
             .unwrap();
@@ -438,8 +465,12 @@ fn bench_rrulestr(c: &mut Criterion) {
             black_box(
                 rrulestr(
                     black_box("DTSTART:20200101T090000\nRRULE:FREQ=DAILY;COUNT=30"),
-                    None, false, false, false,
-                ).unwrap(),
+                    None,
+                    false,
+                    false,
+                    false,
+                )
+                .unwrap(),
             );
         })
     });
@@ -449,8 +480,12 @@ fn bench_rrulestr(c: &mut Criterion) {
             black_box(
                 rrulestr(
                     black_box("DTSTART:20200101T090000\nRRULE:FREQ=WEEKLY;BYDAY=MO,WE,FR;COUNT=52"),
-                    None, false, false, false,
-                ).unwrap(),
+                    None,
+                    false,
+                    false,
+                    false,
+                )
+                .unwrap(),
             );
         })
     });
@@ -481,8 +516,12 @@ fn bench_rrulestr(c: &mut Criterion) {
         b.iter(|| {
             let result = rrulestr(
                 black_box("DTSTART:20200101T090000\nRRULE:FREQ=DAILY;COUNT=100"),
-                None, false, false, false,
-            ).unwrap();
+                None,
+                false,
+                false,
+                false,
+            )
+            .unwrap();
             black_box(result.all());
         })
     });

{python_dateutil_rs-0.1.2 → python_dateutil_rs-0.1.3}/crates/dateutil-core/src/common.rs

@@ -97,6 +97,46 @@ pub const SU: Weekday = Weekday {
     n: None,
 };
 
+// ---------------------------------------------------------------------------
+// Calendar helpers
+// ---------------------------------------------------------------------------
+
+/// Returns `true` if `year` is a leap year (Gregorian calendar).
+#[inline]
+pub(crate) fn is_leap_year(year: i32) -> bool {
+    (year % 4 == 0 && year % 100 != 0) || year % 400 == 0
+}
+
+/// Returns the number of days in the given `month` of `year`.
+///
+/// `month` must be in `1..=12`; out-of-range values return `0`.
+#[inline]
+pub(crate) fn days_in_month(year: i32, month: u32) -> u32 {
+    match month {
+        1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+        4 | 6 | 9 | 11 => 30,
+        2 => {
+            if is_leap_year(year) {
+                29
+            } else {
+                28
+            }
+        }
+        _ => 0,
+    }
+}
+
+/// Create a `NaiveDateTime` from year, month, day, hour, minute, second.
+///
+/// Panics on invalid inputs — intended for test code only.
+#[cfg(test)]
+pub(crate) fn dt(y: i32, m: u32, d: u32, h: u32, mi: u32, s: u32) -> chrono::NaiveDateTime {
+    chrono::NaiveDate::from_ymd_opt(y, m, d)
+        .unwrap()
+        .and_hms_opt(h, mi, s)
+        .unwrap()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -213,12 +253,6 @@ mod tests {
         assert_eq!(set.len(), 2);
     }
 
-    #[test]
-    fn test_weekday_error_display() {
-        let err = Weekday::new(7, None).unwrap_err();
-        assert_eq!(err.to_string(), "invalid weekday: 7 (must be 0..=6)");
-    }
-
     #[test]
     fn test_weekday_i32_min_max_n() {
         let wd = Weekday::new(0, Some(i32::MAX)).unwrap();
@@ -270,4 +304,34 @@ mod tests {
         let result: Result<Weekday, _> = 7u8.try_into();
         assert!(result.is_err());
     }
+
+    // -----------------------------------------------------------------------
+    // Calendar helpers
+    // -----------------------------------------------------------------------
+
+    #[test]
+    fn test_is_leap_year() {
+        assert!(is_leap_year(2024));
+        assert!(!is_leap_year(2023));
+        assert!(!is_leap_year(1900)); // century non-leap
+        assert!(is_leap_year(2000)); // 400-year leap
+        assert!(!is_leap_year(2100)); // century non-leap
+    }
+
+    #[test]
+    fn test_days_in_month() {
+        assert_eq!(days_in_month(2024, 1), 31);
+        assert_eq!(days_in_month(2024, 2), 29); // leap year
+        assert_eq!(days_in_month(2023, 2), 28); // non-leap
+        assert_eq!(days_in_month(2024, 4), 30);
+        assert_eq!(days_in_month(2024, 12), 31);
+        assert_eq!(days_in_month(1900, 2), 28);
+        assert_eq!(days_in_month(2000, 2), 29);
+    }
+
+    #[test]
+    fn test_days_in_month_invalid() {
+        assert_eq!(days_in_month(2024, 0), 0);
+        assert_eq!(days_in_month(2024, 13), 0);
+    }
 }