python-dateutil-rs 0.1.0__tar.gz → 0.1.1__tar.gz

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/Cargo.lock

@@ -220,7 +220,7 @@ checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
 name = "dateutil-core"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "bitflags",
  "chrono",
@@ -233,7 +233,7 @@ dependencies = [
 
 [[package]]
 name = "dateutil-py"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "chrono",
  "dateutil-core",

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/PKG-INFO

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

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dateutil-core"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 license = "MIT"
 description = "Performance-optimized date utility library for Rust"

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/common.rs

@@ -189,30 +189,6 @@ mod tests {
         assert_eq!(wd_neg.to_string(), "SU(-100)");
     }
 
-    #[test]
-    fn test_weekday_negative_one_n() {
-        // Last occurrence (e.g., last Friday of month)
-        let wd = FR.with_n(Some(-1));
-        assert_eq!(wd.n(), Some(-1));
-        assert_eq!(wd.to_string(), "FR(-1)");
-    }
-
-    #[test]
-    fn test_weekday_clone_copy() {
-        let wd = MO.with_n(Some(2));
-        let cloned = wd;
-        assert_eq!(wd, cloned); // Copy semantics — both usable
-    }
-
-    #[test]
-    fn test_weekday_boundary_values() {
-        // Weekday 0 (Monday) and 6 (Sunday) are boundaries
-        let mon = Weekday::new(0, Some(1)).unwrap();
-        let sun = Weekday::new(6, Some(-1)).unwrap();
-        assert_eq!(mon.weekday(), 0);
-        assert_eq!(sun.weekday(), 6);
-    }
-
     #[test]
     fn test_weekday_all_invalid() {
         for i in 7..=255 {
@@ -227,14 +203,6 @@ mod tests {
         assert_ne!(a, b);
     }
 
-    #[test]
-    fn test_weekday_eq_none_vs_zero() {
-        // n=0 is now rejected at construction time (Weekday::new).
-        // with_n() bypasses validation for internal use, so test display.
-        let a = MO.with_n(None);
-        assert_eq!(a.to_string(), "MO");
-    }
-
     #[test]
     fn test_weekday_hash_with_n() {
         use std::collections::HashSet;
@@ -281,14 +249,6 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_weekday_equality_ignores_n_for_same_display() {
-        let a = MO.with_n(Some(1));
-        let b = MO.with_n(Some(-1));
-        assert_ne!(a, b);
-        assert_eq!(a.weekday(), b.weekday());
-    }
-
     #[test]
     fn test_weekday_hash_set_none() {
         use std::collections::HashSet;
@@ -297,4 +257,17 @@ mod tests {
         set.insert(MO.with_n(Some(1)));
         assert_eq!(set.len(), 2);
     }
+
+    #[test]
+    fn test_weekday_try_from_valid() {
+        let wd: Weekday = 3u8.try_into().unwrap();
+        assert_eq!(wd.weekday(), 3);
+        assert_eq!(wd.n(), None);
+    }
+
+    #[test]
+    fn test_weekday_try_from_invalid() {
+        let result: Result<Weekday, _> = 7u8.try_into();
+        assert!(result.is_err());
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/easter.rs

@@ -71,30 +71,6 @@ mod tests {
     use super::*;
     use chrono::Datelike;
 
-    #[test]
-    fn test_western_2024() {
-        assert_eq!(
-            easter(2024, EasterMethod::Western).unwrap(),
-            NaiveDate::from_ymd_opt(2024, 3, 31).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_orthodox_2024() {
-        assert_eq!(
-            easter(2024, EasterMethod::Orthodox).unwrap(),
-            NaiveDate::from_ymd_opt(2024, 5, 5).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_julian_326() {
-        assert_eq!(
-            easter(326, EasterMethod::Julian).unwrap(),
-            NaiveDate::from_ymd_opt(326, 4, 3).unwrap()
-        );
-    }
-
     #[test]
     fn test_invalid_method_from_i32() {
         assert!(matches!(
@@ -107,18 +83,6 @@ mod tests {
         ));
     }
 
-    #[test]
-    fn test_invalid_year() {
-        assert!(matches!(
-            easter(0, EasterMethod::Western),
-            Err(EasterError::InvalidYear(0))
-        ));
-        assert!(matches!(
-            easter(-1, EasterMethod::Western),
-            Err(EasterError::InvalidYear(-1))
-        ));
-    }
-
     #[test]
     fn test_western_range_1990_2050() {
         let expected: Vec<(i32, u32, u32)> = vec![
@@ -347,14 +311,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_orthodox_boundary_exact_1600() {
-        let d1600 = easter(1600, EasterMethod::Orthodox).unwrap();
-        let d1601 = easter(1601, EasterMethod::Orthodox).unwrap();
-        assert!((3..=5).contains(&d1600.month()));
-        assert!((3..=5).contains(&d1601.month()));
-    }
-
     #[test]
     fn test_easter_always_sunday_western_wide_range() {
         // Western (Gregorian) Easter is always Sunday across a wide year range

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/parser/isoparser.rs

@@ -591,4 +591,25 @@ mod tests {
     fn test_iso_leap_second_rejected() {
         assert!(isoparse("2024-01-15T23:59:60").is_err());
     }
+
+    #[test]
+    fn test_iso_hhmm_colon_format() {
+        let dt = isoparse("2024-01-15T10:30").unwrap();
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+        assert_eq!(dt.second(), 0);
+    }
+
+    #[test]
+    fn test_iso_unrecognized_time_format() {
+        let result = isoparse("2024-01-15TX");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_iso_fractional_dot_only() {
+        let dt = isoparse("2024-01-15T10:30:45.").unwrap();
+        assert_eq!(dt.second(), 45);
+        assert_eq!(dt.nanosecond(), 0);
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/parser/parserinfo.rs

@@ -315,4 +315,44 @@ mod tests {
         assert_eq!(do_tzoffset("est", Some(&info)), Some(-18000));
         assert_eq!(do_month("January", Some(&info)), Some(1));
     }
+
+    #[test]
+    fn test_parserinfo_hms() {
+        let info = ParserInfo::default();
+        assert_eq!(info.hms("hour"), Some(0));
+        assert_eq!(info.hms("HOURS"), Some(0));
+        assert_eq!(info.hms("minute"), Some(1));
+        assert_eq!(info.hms("s"), Some(2));
+        assert_eq!(info.hms("xyz"), None);
+    }
+
+    #[test]
+    fn test_parserinfo_ampm() {
+        let info = ParserInfo::default();
+        assert_eq!(info.ampm("am"), Some(0));
+        assert_eq!(info.ampm("AM"), Some(0));
+        assert_eq!(info.ampm("p"), Some(1));
+        assert_eq!(info.ampm("PM"), Some(1));
+        assert_eq!(info.ampm("xyz"), None);
+    }
+
+    #[test]
+    fn test_parserinfo_pertain() {
+        let info = ParserInfo::default();
+        assert!(info.pertain("of"));
+        assert!(info.pertain("OF"));
+        assert!(!info.pertain("xyz"));
+    }
+
+    #[test]
+    fn test_dispatch_with_some_info() {
+        let info = ParserInfo::default();
+        assert!(do_jump(",", Some(&info)));
+        assert_eq!(do_weekday("Monday", Some(&info)), Some(0));
+        assert_eq!(do_month("January", Some(&info)), Some(1));
+        assert_eq!(do_hms("hour", Some(&info)), Some(0));
+        assert_eq!(do_ampm("AM", Some(&info)), Some(0));
+        assert!(do_pertain("of", Some(&info)));
+        assert!(do_utczone("UTC", Some(&info)));
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/parser.rs

@@ -984,22 +984,6 @@ mod tests {
         assert_eq!(dt.second(), 45);
     }
 
-    #[test]
-    fn test_parse_month_name() {
-        let dt = parse("January 15, 2024", false, false, None, None).unwrap();
-        assert_eq!(dt.year(), 2024);
-        assert_eq!(dt.month(), 1);
-        assert_eq!(dt.day(), 15);
-    }
-
-    #[test]
-    fn test_parse_month_abbrev() {
-        let dt = parse("15 Jan 2024", false, false, None, None).unwrap();
-        assert_eq!(dt.year(), 2024);
-        assert_eq!(dt.month(), 1);
-        assert_eq!(dt.day(), 15);
-    }
-
     #[test]
     fn test_parse_us_format() {
         // MM/DD/YYYY (default, dayfirst=false)
@@ -1048,24 +1032,6 @@ mod tests {
         assert_eq!(dt.nanosecond() / 1000, 123456);
     }
 
-    #[test]
-    fn test_parse_tz_offset() {
-        let res = parse_to_result("2024-01-15 10:30:45+05:30", false, false, None).unwrap();
-        assert_eq!(res.tzoffset, Some(5 * 3600 + 30 * 60));
-    }
-
-    #[test]
-    fn test_parse_tz_negative() {
-        let res = parse_to_result("2024-01-15 10:30:45-0800", false, false, None).unwrap();
-        assert_eq!(res.tzoffset, Some(-(8 * 3600)));
-    }
-
-    #[test]
-    fn test_parse_weekday() {
-        let res = parse_to_result("Monday, January 15, 2024", false, false, None).unwrap();
-        assert_eq!(res.weekday, Some(0)); // Monday
-    }
-
     #[test]
     fn test_parse_empty_string() {
         assert!(parse("", false, false, None, None).is_err());
@@ -1162,19 +1128,6 @@ mod tests {
         assert_eq!(res.tzoffset, Some(0));
     }
 
-    #[test]
-    fn test_parse_tz_offset_compact_positive() {
-        let res = parse_to_result("2024-01-15 10:30:00+0530", false, false, None).unwrap();
-        assert_eq!(res.tzoffset, Some(5 * 3600 + 30 * 60));
-    }
-
-    #[test]
-    fn test_parse_tz_offset_zero() {
-        let res = parse_to_result("2024-01-15 10:30:00+0000", false, false, None).unwrap();
-        assert_eq!(res.tzoffset, Some(0));
-        assert_eq!(res.tzname, Some("UTC".into()));
-    }
-
     #[test]
     fn test_parse_month_all_names() {
         let months = [
@@ -1361,13 +1314,6 @@ mod tests {
         assert_eq!(res.year, Some(2024));
     }
 
-    #[test]
-    fn test_parse_time_hh_only() {
-        // "10 hours" — number + HMS word sets hour
-        let res = parse_to_result("2024-01-15 10 hours", false, false, None).unwrap();
-        assert_eq!(res.hour, Some(10));
-    }
-
     #[test]
     fn test_lookup_non_ascii_returns_false() {
         assert!(!lookup_jump("日本語"));
@@ -1578,12 +1524,6 @@ mod tests {
         assert_eq!(dt.year(), 2000);
     }
 
-    #[test]
-    fn test_parse_two_digit_year_99() {
-        let dt = parse("01/15/99", false, false, None, None).unwrap();
-        assert_eq!(dt.year(), 1999);
-    }
-
     // ---- Leap year edge cases ----
 
     #[test]
@@ -1672,14 +1612,6 @@ mod tests {
         assert_eq!(dt.second(), 0);
     }
 
-    #[test]
-    fn test_parse_end_of_day_235959() {
-        let dt = parse("2024-01-15 23:59:59", false, false, None, None).unwrap();
-        assert_eq!(dt.hour(), 23);
-        assert_eq!(dt.minute(), 59);
-        assert_eq!(dt.second(), 59);
-    }
-
     // ---- Fractional seconds precision ----
 
     #[test]
@@ -1688,20 +1620,6 @@ mod tests {
         assert_eq!(dt.nanosecond() / 1000, 100_000);
     }
 
-    #[test]
-    fn test_parse_fractional_6_digits() {
-        let dt = parse("2024-01-15 10:30:45.123456", false, false, None, None).unwrap();
-        assert_eq!(dt.nanosecond() / 1000, 123_456);
-    }
-
-    // ---- ParseResult field_count ----
-
-    #[test]
-    fn test_parse_to_result_minimal() {
-        let res = parse_to_result("2024", false, false, None).unwrap();
-        assert!(res.year.is_some());
-    }
-
     // ---- Only time ----
 
     #[test]
@@ -1770,4 +1688,184 @@ mod tests {
         assert_eq!(dt.day(), 10);
         assert_eq!(dt.hour(), 8);
     }
+
+    // ---- Coverage: compact parsing (try_parse_compact) ----
+
+    #[test]
+    fn test_parse_compact_yyyymmdd() {
+        let dt = parse("20240315", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+        assert_eq!(dt.day(), 15);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymmddt_hhmmss() {
+        // YYYYMMDD + T separator + HHMMSS (6-digit time after date)
+        let dt = parse("20240115T103045", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 1);
+        assert_eq!(dt.day(), 15);
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+        assert_eq!(dt.second(), 45);
+    }
+
+    #[test]
+    fn test_parse_compact_yymmdd() {
+        let default = NaiveDate::from_ymd_opt(2024, 1, 1)
+            .unwrap()
+            .and_hms_opt(0, 0, 0)
+            .unwrap();
+        let dt = parse("240315", false, false, Some(default), None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+        assert_eq!(dt.day(), 15);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymm() {
+        // "202403" → YYMMDD (20/24/03) fails because month=24 > 12
+        // → YYYYMM fallback: year=2024, month=03
+        let dt = parse("202403", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+    }
+
+    #[test]
+    fn test_parse_compact_hhmmss_after_date() {
+        // Date then T then HHMMSS
+        let dt = parse("2024-03-15T103045", false, false, None, None).unwrap();
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+        assert_eq!(dt.second(), 45);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymmddhh() {
+        let dt = parse("2024031510", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+        assert_eq!(dt.day(), 15);
+        assert_eq!(dt.hour(), 10);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymmddhh_with_minutes() {
+        let dt = parse("2024031510:30", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+        assert_eq!(dt.day(), 15);
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymmddhh_with_seconds() {
+        let dt = parse("2024031510:30:45", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2024);
+        assert_eq!(dt.month(), 3);
+        assert_eq!(dt.day(), 15);
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+        assert_eq!(dt.second(), 45);
+    }
+
+    #[test]
+    fn test_parse_compact_yyyymmddhh_with_decimal_seconds() {
+        let dt = parse("2024031510:30:45.5", false, false, None, None).unwrap();
+        assert_eq!(dt.hour(), 10);
+        assert_eq!(dt.minute(), 30);
+        assert_eq!(dt.second(), 45);
+    }
+
+    // ---- Coverage: dot-separated date (try_parse_dot_date) ----
+
+    #[test]
+    fn test_parse_dot_separated_date() {
+        let dt = parse("2003.09.25", false, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2003);
+        assert_eq!(dt.month(), 9);
+        assert_eq!(dt.day(), 25);
+    }
+
+    #[test]
+    fn test_parse_dot_separated_date_dmy() {
+        let dt = parse("25.09.2003", true, false, None, None).unwrap();
+        assert_eq!(dt.year(), 2003);
+        assert_eq!(dt.month(), 9);
+        assert_eq!(dt.day(), 25);
+    }
+
+    // ---- Coverage: timezone parsing ----
+
+    #[test]
+    fn test_parse_tz_offset_single_token() {
+        let res = parse_to_result("2024-01-15 10:30:45 +0500", false, false, None).unwrap();
+        assert_eq!(res.tzoffset, Some(18000));
+    }
+
+    #[test]
+    fn test_parse_tz_name_with_offset() {
+        let res = parse_to_result("2024-01-15 10:30:45 EST -0500", false, false, None).unwrap();
+        assert_eq!(res.tzname.as_deref(), Some("EST"));
+        assert_eq!(res.tzoffset, Some(-18000));
+    }
+
+    #[test]
+    fn test_parse_tz_with_parserinfo() {
+        let mut info = ParserInfo::default();
+        info.tzoffset.insert("est".into(), -18000);
+        let res = parse_to_result("2024-01-15 10:30:45 EST", false, false, Some(&info)).unwrap();
+        assert_eq!(res.tzname.as_deref(), Some("EST"));
+        assert_eq!(res.tzoffset, Some(-18000));
+    }
+
+    // ---- Coverage: pertain word ----
+
+    #[test]
+    fn test_parse_pertain_of() {
+        let dt = parse("15 of January 2024", false, false, None, None).unwrap();
+        assert_eq!(dt.month(), 1);
+        assert_eq!(dt.day(), 15);
+    }
+
+    // ---- Coverage: HMS assign with microseconds ----
+
+    #[test]
+    fn test_parse_hms_label_no_space() {
+        // "10h30m45s" — HMS labels immediately after numbers
+        let res = parse_to_result("10h30m45s", false, false, None).unwrap();
+        assert_eq!(res.hour, Some(10));
+        assert_eq!(res.minute, Some(30));
+        assert_eq!(res.second, Some(45));
+    }
+
+    // ---- Coverage: convertyear edge cases ----
+
+    #[test]
+    fn test_parse_two_digit_year_old() {
+        // Two-digit year far in the past gets + 100
+        let default = NaiveDate::from_ymd_opt(2024, 1, 1)
+            .unwrap()
+            .and_hms_opt(0, 0, 0)
+            .unwrap();
+        let dt = parse("01/15/70", false, false, Some(default), None).unwrap();
+        // 70 should map to 1970 (2070 - 100 = 1970... or 2070 if < now+50)
+        assert!(dt.year() == 1970 || dt.year() == 2070);
+    }
+
+    // ---- Coverage: fast_parse_int / fast_parse_decimal edge cases ----
+
+    #[test]
+    fn test_fast_parse_int_empty() {
+        assert_eq!(fast_parse_int(""), None);
+    }
+
+    #[test]
+    fn test_fast_parse_decimal_empty_frac() {
+        // "10." — dot at end, empty frac part → (10, 0)
+        assert_eq!(fast_parse_decimal("10."), Some((10, 0)));
+    }
+
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/relativedelta.rs

@@ -1769,4 +1769,156 @@ mod tests {
         set.insert(rd(0, 0, 1));
         assert_eq!(set.len(), 2);
     }
+
+    // ---- Coverage: Display impl for absolute fields ----
+
+    #[test]
+    fn test_display_with_absolute_fields() {
+        let delta = RelativeDelta::builder()
+            .year(2024)
+            .month(3)
+            .day(15)
+            .hour(10)
+            .minute(30)
+            .second(45)
+            .microsecond(123456)
+            .build()
+            .unwrap();
+        let s = delta.to_string();
+        assert!(s.contains("year=2024"));
+        assert!(s.contains("month=3"));
+        assert!(s.contains("day=15"));
+        assert!(s.contains("hour=10"));
+        assert!(s.contains("minute=30"));
+        assert!(s.contains("second=45"));
+        assert!(s.contains("microsecond=123456"));
+    }
+
+    #[test]
+    fn test_display_with_weekday() {
+        use crate::common::MO;
+        let delta = RelativeDelta::builder()
+            .weekday(MO)
+            .build()
+            .unwrap();
+        let s = delta.to_string();
+        assert!(s.contains("weekday=MO"));
+    }
+
+    #[test]
+    fn test_display_relative_parts() {
+        let delta = rd(1, 2, 3);
+        let s = delta.to_string();
+        assert!(s.starts_with("relativedelta("));
+        assert!(s.contains("years=+1"));
+        assert!(s.contains("months=+2"));
+        assert!(s.contains("days=+3"));
+        assert!(s.ends_with(')'));
+    }
+
+    // ---- Coverage: set_weeks ----
+
+    #[test]
+    fn test_set_weeks() {
+        let mut delta = RelativeDelta::builder()
+            .days(10)
+            .build()
+            .unwrap();
+        assert_eq!(delta.weeks(), 1);
+        delta.set_weeks(3);
+        assert_eq!(delta.days(), 24); // 3*7 + 3 = 24
+        assert_eq!(delta.weeks(), 3);
+    }
+
+    // ---- Coverage: leapdays with march+ in leap year ----
+
+    #[test]
+    fn test_leapdays_in_leap_year() {
+        let delta = RelativeDelta::builder()
+            .leapdays(1)
+            .build()
+            .unwrap();
+        let base = NaiveDate::from_ymd_opt(2024, 3, 1).unwrap(); // Leap year, March
+        let result = delta.add_to_naive_date(base);
+        // March in a leap year: leapdays should be added
+        assert_eq!(result, NaiveDate::from_ymd_opt(2024, 3, 2).unwrap());
+    }
+
+    // ---- Coverage: weekday_eq / normalize_n ----
+
+    #[test]
+    fn test_weekday_equality_in_relativedelta() {
+        use crate::common::{MO, TU};
+        let a = RelativeDelta::builder()
+            .weekday(MO)
+            .build()
+            .unwrap();
+        let b = RelativeDelta::builder()
+            .weekday(MO)
+            .build()
+            .unwrap();
+        assert_eq!(a, b);
+
+        let c = RelativeDelta::builder()
+            .weekday(TU)
+            .build()
+            .unwrap();
+        assert_ne!(a, c);
+
+        let d = RelativeDelta::builder().build().unwrap();
+        assert_ne!(a, d);
+    }
+
+    #[test]
+    fn test_hash_with_weekday() {
+        use crate::common::MO;
+        use std::collections::hash_map::DefaultHasher;
+
+        let a = RelativeDelta::builder()
+            .weekday(MO)
+            .build()
+            .unwrap();
+        let b = RelativeDelta::builder()
+            .weekday(MO)
+            .build()
+            .unwrap();
+
+        let hash_a = {
+            let mut h = DefaultHasher::new();
+            a.hash(&mut h);
+            h.finish()
+        };
+        let hash_b = {
+            let mut h = DefaultHasher::new();
+            b.hash(&mut h);
+            h.finish()
+        };
+        assert_eq!(hash_a, hash_b);
+    }
+
+    #[test]
+    fn test_hash_with_microsecond() {
+        use std::collections::hash_map::DefaultHasher;
+
+        let a = RelativeDelta::builder()
+            .microsecond(500)
+            .build()
+            .unwrap();
+        let b = RelativeDelta::builder()
+            .microsecond(500)
+            .build()
+            .unwrap();
+
+        let hash_a = {
+            let mut h = DefaultHasher::new();
+            a.hash(&mut h);
+            h.finish()
+        };
+        let hash_b = {
+            let mut h = DefaultHasher::new();
+            b.hash(&mut h);
+            h.finish()
+        };
+        assert_eq!(hash_a, hash_b);
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/rrule/parse.rs

@@ -1107,4 +1107,29 @@ mod tests {
         );
         assert!(err.is_err());
     }
+
+    // ---- Coverage: error paths in parse ----
+
+    #[test]
+    fn test_rrulestr_invalid_param_without_equals() {
+        // "FREQ" without "=" should error
+        let result = rrulestr("FREQ", None, false, false, false);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_rrulestr_unknown_param_name() {
+        // "XRULE:FREQ=DAILY" — unknown type prefix
+        let result = rrulestr("XRULE:FREQ=DAILY;COUNT=3", None, false, false, true);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_rrulestr_line_unfold() {
+        // Test RFC line unfolding (continuation lines starting with space)
+        let input = "DTSTART:20200101T000000\nRRULE:FREQ=DAILY;\n COUNT=3";
+        let result = rrulestr(input, None, false, false, true);
+        assert!(result.is_ok());
+        assert_eq!(result.unwrap().all().len(), 3);
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/rrule/set.rs

@@ -645,4 +645,42 @@ mod tests {
             ]
         );
     }
+
+    // ---- Coverage: Default impl ----
+
+    #[test]
+    fn test_rruleset_default() {
+        let rset: RRuleSet = Default::default();
+        assert!(rset.is_finite()); // empty set is finite
+    }
+
+    // ---- Coverage: exrule exclusion ----
+
+    #[test]
+    fn test_rruleset_exrule() {
+        let mut rset = RRuleSet::new();
+        // Daily for 10 days
+        let rule = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(10)
+            .build()
+            .unwrap();
+        rset.rrule(rule);
+
+        // Exclude every other day (interval=2)
+        let exrule = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 2, 0, 0, 0))
+            .interval(2)
+            .count(5)
+            .build()
+            .unwrap();
+        rset.exrule(exrule);
+
+        let results = rset.all();
+        // Should exclude Jan 2, 4, 6, 8, 10
+        assert!(results.contains(&dt(2020, 1, 1, 0, 0, 0)));
+        assert!(!results.contains(&dt(2020, 1, 2, 0, 0, 0)));
+        assert!(results.contains(&dt(2020, 1, 3, 0, 0, 0)));
+        assert!(!results.contains(&dt(2020, 1, 4, 0, 0, 0)));
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/rrule.rs

@@ -3344,4 +3344,225 @@ mod tests {
         let result = rule.take_slice(5, 5, 1);
         assert!(result.is_empty());
     }
+
+    // ---- Coverage: getter methods ----
+
+    #[test]
+    fn test_rrule_getters() {
+        let rule = RRuleBuilder::new(Frequency::Monthly)
+            .dtstart(dt(2020, 1, 1, 9, 0, 0))
+            .interval(2)
+            .count(5)
+            .bymonth(vec![1, 6])
+            .bysetpos(vec![1, -1])
+            .byweekno(vec![1, 52])
+            .byyearday(vec![1, 365])
+            .byeaster(vec![0])
+            .byhour(vec![9, 17])
+            .byminute(vec![0, 30])
+            .bysecond(vec![0])
+            .build()
+            .unwrap();
+
+        assert_eq!(rule.freq(), Frequency::Monthly);
+        assert_eq!(rule.dtstart(), dt(2020, 1, 1, 9, 0, 0));
+        assert_eq!(rule.interval(), 2);
+        assert_eq!(rule.wkst(), 0);
+        assert_eq!(rule.count(), Some(5));
+        assert_eq!(rule.until(), None);
+        assert!(rule.bysetpos().is_some());
+        assert!(rule.bymonth().is_some());
+        assert!(rule.byyearday().is_some());
+        assert!(rule.byeaster().is_some());
+        assert!(rule.byweekno().is_some());
+        assert!(rule.byhour().is_some());
+        assert!(rule.byminute().is_some());
+        assert!(rule.bysecond().is_some());
+    }
+
+    #[test]
+    fn test_rrule_bymonthday_and_bynmonthday() {
+        let rule = RRuleBuilder::new(Frequency::Monthly)
+            .dtstart(dt(2020, 1, 15, 0, 0, 0))
+            .count(3)
+            .build()
+            .unwrap();
+        // Default bymonthday should be dtstart day
+        assert!(!rule.bymonthday().is_empty());
+        assert!(rule.bynmonthday().is_empty());
+    }
+
+    #[test]
+    fn test_rrule_byweekday_getter() {
+        use crate::common::{MO, FR};
+        let rule = RRuleBuilder::new(Frequency::Weekly)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(5)
+            .byweekday(vec![MO, FR])
+            .build()
+            .unwrap();
+        assert!(rule.byweekday().is_some());
+    }
+
+    #[test]
+    fn test_rrule_bynweekday_getter() {
+        use crate::common::MO;
+        let rule = RRuleBuilder::new(Frequency::Monthly)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(3)
+            .byweekday(vec![MO.with_n(Some(2))])
+            .build()
+            .unwrap();
+        assert!(rule.bynweekday().is_some());
+    }
+
+    // ---- Coverage: is_empty, all() panic ----
+
+    #[test]
+    fn test_recurrence_is_empty() {
+        // Rule that produces no results (month 13 doesn't exist)
+        let rule = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(0)
+            .build()
+            .unwrap();
+        assert!(rule.is_empty());
+    }
+
+    #[test]
+    #[should_panic(expected = "all() called on infinite")]
+    fn test_all_panics_on_infinite() {
+        let rule = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .build()
+            .unwrap();
+        let _ = rule.all();
+    }
+
+    // ---- Coverage: len() ----
+
+    #[test]
+    fn test_recurrence_len_finite_and_infinite() {
+        let rule = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(5)
+            .build()
+            .unwrap();
+        assert_eq!(rule.len(), Some(5));
+
+        let infinite = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .build()
+            .unwrap();
+        assert_eq!(infinite.len(), None);
+    }
+
+    // ---- Coverage: Arc<RRule> iter ----
+
+    #[test]
+    fn test_arc_rrule_iter() {
+        let rule = Arc::new(
+            RRuleBuilder::new(Frequency::Daily)
+                .dtstart(dt(2020, 1, 1, 0, 0, 0))
+                .count(3)
+                .build()
+                .unwrap(),
+        );
+        let results: Vec<_> = rule.iter().collect();
+        assert_eq!(results.len(), 3);
+        assert!(rule.is_finite());
+    }
+
+    // ---- Coverage: Display impl for RRULE ----
+
+    #[test]
+    fn test_rrule_display_with_bysetpos() {
+        let rule = RRuleBuilder::new(Frequency::Monthly)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(3)
+            .bysetpos(vec![1, -1])
+            .bymonth(vec![1, 6])
+            .byyearday(vec![1, 100])
+            .byweekno(vec![1, 52])
+            .byhour(vec![9, 17])
+            .byminute(vec![0, 30])
+            .bysecond(vec![0])
+            .byeaster(vec![0, -2])
+            .build()
+            .unwrap();
+        let s = rule.to_string();
+        assert!(s.contains("BYSETPOS=1,-1"));
+        assert!(s.contains("BYMONTH="));
+        assert!(s.contains("BYYEARDAY="));
+        assert!(s.contains("BYWEEKNO="));
+        assert!(s.contains("BYHOUR="));
+        assert!(s.contains("BYMINUTE="));
+        assert!(s.contains("BYSECOND="));
+        assert!(s.contains("BYEASTER="));
+    }
+
+    #[test]
+    fn test_rrule_display_with_bymonthday() {
+        let rule = RRuleBuilder::new(Frequency::Monthly)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .count(3)
+            .bymonthday(vec![1, 15])
+            .build()
+            .unwrap();
+        let s = rule.to_string();
+        assert!(s.contains("BYMONTHDAY="));
+    }
+
+    // ---- Coverage: construct_byset empty error ----
+
+    #[test]
+    fn test_construct_byset_empty() {
+        // interval=2, start=0, byxxx=[1] → gcd(2,24)=2, 1%2=1≠0 → empty
+        let result = construct_byset(0, &[1], 24, 2);
+        assert!(result.is_err());
+    }
+
+    // ---- Coverage: mod_distance returns None ----
+
+    #[test]
+    fn test_mod_distance_none() {
+        // No matching value within base iterations
+        let result = mod_distance(0, &[], 60, 1);
+        assert_eq!(result, None);
+    }
+
+    // ---- Coverage: days_in_month invalid month ----
+
+    #[test]
+    fn test_days_in_month_invalid() {
+        assert_eq!(days_in_month(2024, 0), 0);
+        assert_eq!(days_in_month(2024, 13), 0);
+    }
+
+    // ---- Coverage: invalid wkst ----
+
+    #[test]
+    fn test_builder_invalid_wkst_7() {
+        let result = RRuleBuilder::new(Frequency::Daily)
+            .dtstart(dt(2020, 1, 1, 0, 0, 0))
+            .wkst(7)
+            .build();
+        assert!(result.is_err());
+    }
+
+    // ---- Coverage: freq > Monthly with nth weekday (flattened to plain) ----
+
+    #[test]
+    fn test_weekly_nth_weekday_flattened() {
+        use crate::common::MO;
+        // nth weekday with freq > Monthly → pushed to plain weekday
+        let rule = RRuleBuilder::new(Frequency::Weekly)
+            .dtstart(dt(2020, 1, 6, 0, 0, 0)) // Monday
+            .count(3)
+            .byweekday(vec![MO.with_n(Some(2))])
+            .build()
+            .unwrap();
+        let results = rule.all();
+        assert_eq!(results.len(), 3);
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/tz/offset.rs

@@ -230,4 +230,16 @@ mod tests {
         set.insert(a);
         assert!(set.contains(&b));
     }
+
+    #[test]
+    fn test_display_name_method() {
+        let named = TzOffset::new(Some("EST"), -5 * 3600);
+        assert_eq!(named.display_name(), "EST");
+
+        let unnamed = TzOffset::new(None, 5 * 3600 + 1800);
+        assert_eq!(unnamed.display_name(), "UTC+05:30");
+
+        let utc = TzOffset::new(None, 0);
+        assert_eq!(utc.display_name(), "UTC");
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-core/src/tz.rs

@@ -315,20 +315,6 @@ mod tests {
     // gettz()
     // -----------------------------------------------------------------------
 
-    #[test]
-    fn test_gettz_utc() {
-        let tz = gettz(Some("UTC")).unwrap();
-        let d = dt(2024, 1, 1, 0, 0, 0);
-        assert_eq!(tz.utcoffset(d, false), 0);
-        assert_eq!(tz.tzname(d, false), "UTC");
-    }
-
-    #[test]
-    fn test_gettz_gmt() {
-        let tz = gettz(Some("GMT")).unwrap();
-        assert_eq!(tz.utcoffset(dt(2024, 1, 1, 0, 0, 0), false), 0);
-    }
-
     #[test]
     fn test_gettz_iana_name() {
         let tz = gettz(Some("America/New_York")).unwrap();
@@ -589,4 +575,42 @@ mod tests {
         // July is WINTER: AEST (UTC+10)
         assert_eq!(tz.utcoffset(dt(2024, 7, 15, 12, 0, 0), false), 10 * 3600);
     }
+
+    // ---- Coverage: TimeZone dispatch for Local variant ----
+
+    #[test]
+    fn test_timezone_local_dst() {
+        let tz = gettz(None).unwrap(); // local timezone
+        let d = dt(2024, 7, 15, 12, 0, 0);
+        // Just verify it doesn't panic
+        let _ = tz.dst(d, false);
+    }
+
+    #[test]
+    fn test_timezone_local_tzname() {
+        let tz = gettz(None).unwrap();
+        let d = dt(2024, 1, 15, 12, 0, 0);
+        let name = tz.tzname(d, false);
+        assert!(!name.is_empty());
+    }
+
+    #[test]
+    fn test_timezone_local_is_ambiguous() {
+        let tz = gettz(None).unwrap();
+        let d = dt(2024, 6, 15, 12, 0, 0);
+        // Just verify it doesn't panic; midday is never ambiguous
+        let _ = tz.is_ambiguous(d);
+    }
+
+    #[test]
+    fn test_timezone_local_fromutc() {
+        let tz = gettz(None).unwrap();
+        let d = dt(2024, 1, 15, 12, 0, 0);
+        let wall = tz.fromutc(d);
+        // fromutc should shift by the local offset
+        let offset = tz.utcoffset(wall, false);
+        // The difference should match the offset
+        let diff = (wall - d).num_seconds() as i32;
+        assert_eq!(diff, offset);
+    }
 }

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/crates/dateutil-py/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "dateutil-py"
-version = "0.1.0"
+version = "0.1.1"
 edition = "2021"
 license = "MIT"
 description = "PyO3 bindings for the dateutil-core crate"

{python_dateutil_rs-0.1.0 → python_dateutil_rs-0.1.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-dateutil-rs"
-version = "0.1.0"
+version = "0.1.1"
 description = "A Rust-backed port of python-dateutil"
 readme = "README.md"
 license = "MIT"

python_dateutil_rs-0.1.1/python/dateutil_rs/easter.py

@@ -0,0 +1,15 @@
+"""dateutil_rs.easter - Easter date calculation."""
+
+from dateutil_rs._native import (
+    EASTER_JULIAN,
+    EASTER_ORTHODOX,
+    EASTER_WESTERN,
+    easter,
+)
+
+__all__ = [
+    "EASTER_JULIAN",
+    "EASTER_ORTHODOX",
+    "EASTER_WESTERN",
+    "easter",
+]

python_dateutil_rs-0.1.1/python/dateutil_rs/relativedelta.py

@@ -0,0 +1,5 @@
+"""dateutil_rs.relativedelta - Relative date/time arithmetic."""
+
+from dateutil_rs._native import relativedelta
+
+__all__ = ["relativedelta"]

python_dateutil_rs-0.1.1/python/dateutil_rs/rrule.py

@@ -0,0 +1,27 @@
+"""dateutil_rs.rrule - RFC 5545 recurrence rules."""
+
+from dateutil_rs._native import (
+    DAILY,
+    HOURLY,
+    MINUTELY,
+    MONTHLY,
+    SECONDLY,
+    WEEKLY,
+    YEARLY,
+    rrule,
+    rruleset,
+    rrulestr,
+)
+
+__all__ = [
+    "DAILY",
+    "HOURLY",
+    "MINUTELY",
+    "MONTHLY",
+    "SECONDLY",
+    "WEEKLY",
+    "YEARLY",
+    "rrule",
+    "rruleset",
+    "rrulestr",
+]

python_dateutil_rs-0.1.1/python/dateutil_rs/tz.py

@@ -0,0 +1,23 @@
+"""dateutil_rs.tz - Timezone types and utilities."""
+
+from dateutil_rs._native import (
+    datetime_ambiguous,
+    datetime_exists,
+    gettz,
+    resolve_imaginary,
+    tzfile,
+    tzlocal,
+    tzoffset,
+    tzutc,
+)
+
+__all__ = [
+    "datetime_ambiguous",
+    "datetime_exists",
+    "gettz",
+    "resolve_imaginary",
+    "tzfile",
+    "tzlocal",
+    "tzoffset",
+    "tzutc",
+]