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

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

@@ -219,24 +219,25 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
 
 [[package]]
-name = "dateutil-core"
-version = "0.1.1"
+name = "dateutil"
+version = "0.1.2"
 dependencies = [
  "bitflags",
  "chrono",
  "criterion",
  "iana-time-zone",
  "phf",
+ "rustc-hash",
  "smallvec",
  "thiserror",
 ]
 
 [[package]]
 name = "dateutil-py"
-version = "0.1.1"
+version = "0.1.2"
 dependencies = [
  "chrono",
- "dateutil-core",
+ "dateutil",
  "pyo3",
 ]
 
@@ -576,6 +577,12 @@ version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc897dd8d9e8bd1ed8cdad82b5966c3e0ecae09fb1907d58efaa013543185d0a"
 
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
 [[package]]
 name = "rustversion"
 version = "1.0.22"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-dateutil-rs
-Version: 0.1.1
+Version: 0.1.2
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -142,7 +142,7 @@ Benchmarks compare the original `python-dateutil` (PyPI) and the Rust extension
 | Parser (parse) | **19.5x-36.0x** |
 | Parser (isoparse) | **13.0x-38.4x** |
 | RRule | **5.9x-63.7x** |
-| Timezone | **1.0x-896.7x** ¹ |
+| Timezone | **1.0x-896.7x** |
 | RelativeDelta | **2.0x-28.1x** |
 | Easter | **5.0x-7.3x** |
 

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/README.md

@@ -120,7 +120,7 @@ Benchmarks compare the original `python-dateutil` (PyPI) and the Rust extension
 | Parser (parse) | **19.5x-36.0x** |
 | Parser (isoparse) | **13.0x-38.4x** |
 | RRule | **5.9x-63.7x** |
-| Timezone | **1.0x-896.7x** ¹ |
+| Timezone | **1.0x-896.7x** |
 | RelativeDelta | **2.0x-28.1x** |
 | Easter | **5.0x-7.3x** |
 

python_dateutil_rs-0.1.2/crates/dateutil-core/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "dateutil"
+version = "0.1.2"
+edition = "2021"
+license = "MIT"
+description = "Fast date utility library — parser, relativedelta, rrule, timezone (Rust reimplementation of python-dateutil)"
+repository = "https://github.com/wakita181009/dateutil-rs"
+keywords = ["date", "datetime", "parser", "rrule", "timezone"]
+categories = ["date-and-time", "parser-implementations"]
+readme = "README.md"
+
+[lib]
+name = "dateutil"
+crate-type = ["rlib"]
+
+[dependencies]
+bitflags = "2"
+chrono = "0.4"
+phf = { version = "0.13", features = ["macros"] }
+rustc-hash = "2"
+smallvec = "1.15"
+thiserror = "2"
+iana-time-zone = "0.1"
+
+[dev-dependencies]
+criterion = { version = "0.8", features = ["html_reports"] }
+
+[[bench]]
+name = "benchmarks"
+harness = false

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

@@ -0,0 +1,209 @@
+# python-dateutil-rs
+
+[![PyPI](https://img.shields.io/pypi/v/python-dateutil-rs.svg?style=flat-square)](https://pypi.org/project/python-dateutil-rs/)
+[![Python](https://img.shields.io/pypi/pyversions/python-dateutil-rs.svg?style=flat-square)](https://pypi.org/project/python-dateutil-rs/)
+[![License](https://img.shields.io/pypi/l/python-dateutil-rs.svg?style=flat-square)](https://pypi.org/project/python-dateutil-rs/)
+[![CI](https://github.com/wakita181009/dateutil-rs/actions/workflows/ci.yml/badge.svg)](https://github.com/wakita181009/dateutil-rs/actions/workflows/ci.yml)
+[![Coverage](https://codecov.io/gh/wakita181009/dateutil-rs/branch/main/graph/badge.svg)](https://codecov.io/gh/wakita181009/dateutil-rs)
+
+A high-performance Rust-backed port of [python-dateutil](https://github.com/dateutil/dateutil) (v2.9.0).
+
+> **Status:** All core modules (easter, relativedelta, parser, rrule, tz) are rewritten in Rust via PyO3/maturin. The optimized `dateutil-core` + `dateutil-py` architecture delivers **2x-897x** speedups over python-dateutil.
+
+## Features
+
+- **Drop-in replacement** for `python-dateutil` — same API, same behavior
+- **Rust-accelerated:** easter, relativedelta, parser (`parse` / `isoparse`), rrule, tz, weekday
+- **Optimized core:** zero-copy parser, PHF lookup tables, bitflag filters, buffer-reusing rrule
+- **Comprehensive test suite** inherited from the original project
+- **Benchmark infrastructure** for side-by-side performance comparison
+- **Python 3.10-3.14** supported on Linux and macOS
+
+## Installation
+
+```bash
+pip install python-dateutil-rs
+```
+
+## Usage
+
+```python
+from dateutil_rs import (
+    parse, isoparse, relativedelta, rrule, rruleset, rrulestr,
+    easter, gettz, tzutc, tzoffset,
+    MONTHLY, MO, TU, WE, TH, FR, SA, SU,
+)
+
+# Parse date strings (zero-copy tokenizer)
+dt = parse("2026-01-15T10:30:00+09:00")
+
+# ISO-8601 strict parsing
+dt = isoparse("2026-01-15T10:30:00")
+
+# Relative deltas
+next_month = dt + relativedelta(months=+1)
+
+# Recurrence rules (buffer-reusing iterator)
+monthly = rrule(MONTHLY, count=5, dtstart=parse("2026-01-01"))
+dates = monthly.all()
+dates = list(monthly)           # also iterable
+first = monthly[0]              # indexing
+subset = monthly[1:3]           # slicing
+n = monthly.count()             # total occurrences
+dt in monthly                   # membership test
+
+# Timezones
+tokyo = gettz("Asia/Tokyo")
+utc = tzutc()
+
+# Easter
+easter_date = easter(2026)
+```
+
+## Development
+
+### Prerequisites
+
+- Python 3.10+
+- Rust toolchain
+- [uv](https://github.com/astral-sh/uv) (recommended) or pip
+
+### Setup
+
+```bash
+git clone https://github.com/wakita181009/dateutil-rs.git
+cd dateutil-rs
+uv sync --extra dev
+```
+
+### Building
+
+```bash
+# Build the native extension
+maturin develop --release
+
+# Development build (faster compilation)
+maturin develop -F python
+```
+
+### Running Tests
+
+```bash
+# Run the test suite
+uv run pytest tests/ -x -q
+
+# Run with coverage
+uv run pytest tests/ --cov=dateutil_rs
+
+# Run Rust tests
+cargo test -p dateutil-core
+cargo test --workspace
+```
+
+### Linting
+
+```bash
+uv run ruff check tests/ python/
+uv run ruff format --check tests/ python/
+uv run mypy python/
+cargo clippy --workspace
+```
+
+### Benchmarks
+
+Benchmarks compare the original `python-dateutil` (PyPI) and the Rust extension (`dateutil_rs`) using pytest-benchmark.
+
+#### Summary (vs python-dateutil)
+
+| 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** |
+
+> Measured on Apple Silicon (M-series), Python 3.13, release build. Full results: [benchmarks/RESULTS.md](benchmarks/RESULTS.md)
+
+```bash
+# Install the original python-dateutil for comparison
+uv pip install python-dateutil
+
+# Run benchmarks
+make bench
+
+# Run and save results as JSON
+make bench-save
+```
+
+## Project Structure
+
+```
+dateutil-rs/
+├── Cargo.toml                 # Workspace root
+├── pyproject.toml             # Python project config (maturin)
+├── crates/
+│   ├── dateutil-core/         # Pure Rust optimized core (crates.io)
+│   │   └── src/
+│   │       ├── lib.rs         # Crate root, public API
+│   │       ├── common.rs      # Weekday (MO-SU with N-th occurrence)
+│   │       ├── easter.rs      # Easter date calculations
+│   │       ├── error.rs       # Shared error types
+│   │       ├── relativedelta.rs
+│   │       ├── parser.rs      # parse() entry point
+│   │       ├── parser/        # tokenizer, parserinfo, isoparser
+│   │       ├── rrule.rs       # RRule entry point
+│   │       ├── rrule/         # iter, parse (rrulestr), set
+│   │       └── tz/            # tzutc, tzoffset, tzfile, tzlocal
+│   └── dateutil-py/           # PyO3 binding layer → PyPI package
+│       └── src/
+│           ├── lib.rs         # Module registration
+│           ├── py.rs          # Binding root + #[pymodule]
+│           └── py/            # Per-module bindings (common, conv, easter, parser, relativedelta, rrule, tz)
+├── python/dateutil_rs/        # Python package (maturin mixed layout)
+│   ├── __init__.py            # Re-exports from Rust native module
+│   ├── _native.pyi            # Type stubs for native module
+│   ├── py.typed               # PEP 561 marker
+│   └── parser.py              # parserinfo (Python subclass support)
+├── tests/                     # Python test suite
+├── benchmarks/                # pytest-benchmark comparisons
+├── .github/workflows/         # CI (ci.yml, publish.yml)
+├── Makefile
+└── LICENSE
+```
+
+### Crate Roles
+
+| Crate | Purpose | PyO3 | Publish To |
+|-------|---------|------|------------|
+| `dateutil-core` | Pure Rust optimized core | No | crates.io |
+| `dateutil-py` | PyO3 binding layer | Yes | PyPI (`python-dateutil-rs`) |
+
+## Implementation Status
+
+| Module | Status | Notes |
+|--------|:------:|-------|
+| common (Weekday) | ✅ | MO-SU constants with N-th occurrence |
+| easter | ✅ | 5.0x-7.3x faster, 3 calendar methods |
+| relativedelta | ✅ | 2.0x-28.1x faster |
+| parser (parse) | ✅ | 19.5x-36.0x faster, zero-copy tokenizer, PHF lookups |
+| parser (isoparse) | ✅ | 13.0x-38.4x faster |
+| parser (parserinfo) | ✅ | Customizable via Python subclass |
+| rrule / rruleset | ✅ | 5.9x-63.7x faster, bitflag filters, buffer reuse |
+| rrulestr | ✅ | RFC 5545 string parsing |
+| tz (tzutc, tzoffset, tzfile, tzlocal) | ✅ | 1.0x-896.7x faster |
+| tz utilities (gettz, datetime_exists, etc.) | ✅ | gettz with caching |
+
+## Roadmap
+
+1. ~~Python-only phase — Pure Python port with full test coverage~~ ✅
+2. ~~Rust core + PyO3 bindings — easter, relativedelta, parser, weekday~~ ✅
+3. ~~Rust rrule — Rewrite recurrence rules in Rust~~ ✅
+4. ~~Rust tz — Rewrite timezone support in Rust~~ ✅
+5. ~~Optimized core — zero-copy parser, buffer-reusing rrule, consolidated architecture~~ ✅
+6. **Release** — Publish dateutil-core to crates.io and python-dateutil-rs 1.0 to PyPI
+
+## License
+
+[MIT](LICENSE)

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/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 dateutil_core::common::Weekday;
-use dateutil_core::easter::{easter, EasterMethod};
-use dateutil_core::parser;
-use dateutil_core::parser::tokenizer;
-use dateutil_core::relativedelta::RelativeDelta;
-use dateutil_core::rrule::{Frequency, Recurrence, RRuleBuilder};
-use dateutil_core::rrule::parse::rrulestr;
-use dateutil_core::rrule::set::RRuleSet;
+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;
 
 fn bench_tokenizer(c: &mut Criterion) {
     c.bench_function("tokenize_simple_date", |b| {

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

@@ -115,6 +115,11 @@ pub fn rrulestr(
                 }
             }
         } else if prop.eq_ignore_ascii_case("DTSTART") {
+            if value.contains(',') {
+                return Err(RRuleError::ValueError(
+                    "DTSTART must be a single date-time value".into(),
+                ));
+            }
             if let Some(dt) = parse_rfc_datetime(value) {
                 dtstart = Some(dt);
             }

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

@@ -13,13 +13,70 @@ pub use offset::TzOffset;
 pub use file::{TzFile, TzFileData};
 pub use local::TzLocal;
 
-use std::collections::HashMap;
 use std::sync::{LazyLock, RwLock};
 
+use rustc_hash::FxHashMap;
+
 use chrono::{NaiveDateTime, TimeDelta};
 
 use crate::error::TzError;
 
+// ---------------------------------------------------------------------------
+// TzOps — shared trait for all timezone types
+// ---------------------------------------------------------------------------
+
+/// Core timezone operations shared by all timezone types.
+///
+/// Implemented by `TzUtc`, `TzOffset`, `TzFile`, `TzLocal`, and `TimeZone`.
+/// Helper functions like `datetime_exists` and `resolve_imaginary` are generic
+/// over this trait, so callers can use any timezone type without constructing
+/// the `TimeZone` enum (avoiding clones in the PyO3 binding layer).
+pub trait TzOps {
+    /// UTC offset in seconds for a wall-clock datetime.
+    /// `fold` disambiguates repeated wall times (PEP 495).
+    fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32;
+    /// DST offset component in seconds.
+    fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32;
+    /// Timezone abbreviation string.
+    fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str;
+    /// Whether the given wall time is ambiguous (falls in a DST overlap).
+    fn is_ambiguous(&self, dt: NaiveDateTime) -> bool;
+    /// Convert a UTC datetime to wall time.
+    fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime;
+}
+
+impl TzOps for TzUtc {
+    #[inline] fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.utcoffset(dt, fold) }
+    #[inline] fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.dst(dt, fold) }
+    #[inline] fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str { self.tzname(dt, fold) }
+    #[inline] fn is_ambiguous(&self, dt: NaiveDateTime) -> bool { self.is_ambiguous(dt) }
+    #[inline] fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime { self.fromutc(dt) }
+}
+
+impl TzOps for TzOffset {
+    #[inline] fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.utcoffset(dt, fold) }
+    #[inline] fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.dst(dt, fold) }
+    #[inline] fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str { self.tzname(dt, fold) }
+    #[inline] fn is_ambiguous(&self, dt: NaiveDateTime) -> bool { self.is_ambiguous(dt) }
+    #[inline] fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime { self.fromutc(dt) }
+}
+
+impl TzOps for TzFile {
+    #[inline] fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.utcoffset(dt, fold) }
+    #[inline] fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.dst(dt, fold) }
+    #[inline] fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str { self.tzname(dt, fold) }
+    #[inline] fn is_ambiguous(&self, dt: NaiveDateTime) -> bool { self.is_ambiguous(dt) }
+    #[inline] fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime { self.fromutc(dt) }
+}
+
+impl TzOps for TzLocal {
+    #[inline] fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.utcoffset(dt, fold) }
+    #[inline] fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 { self.dst(dt, fold) }
+    #[inline] fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str { self.tzname(dt, fold) }
+    #[inline] fn is_ambiguous(&self, dt: NaiveDateTime) -> bool { self.is_ambiguous(dt) }
+    #[inline] fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime { self.fromutc(dt) }
+}
+
 // ---------------------------------------------------------------------------
 // TimeZone — enum dispatch for all timezone types
 // ---------------------------------------------------------------------------
@@ -37,11 +94,9 @@ pub enum TimeZone {
     Local(TzLocal),
 }
 
-impl TimeZone {
-    /// UTC offset in seconds for a wall-clock datetime.
-    /// `fold` disambiguates repeated wall times (PEP 495).
+impl TzOps for TimeZone {
     #[inline]
-    pub fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 {
+    fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 {
         match self {
             TimeZone::Utc(tz) => tz.utcoffset(dt, fold),
             TimeZone::Offset(tz) => tz.utcoffset(dt, fold),
@@ -50,9 +105,8 @@ impl TimeZone {
         }
     }
 
-    /// DST offset component in seconds.
     #[inline]
-    pub fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 {
+    fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 {
         match self {
             TimeZone::Utc(tz) => tz.dst(dt, fold),
             TimeZone::Offset(tz) => tz.dst(dt, fold),
@@ -61,9 +115,8 @@ impl TimeZone {
         }
     }
 
-    /// Timezone abbreviation string.
     #[inline]
-    pub fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str {
+    fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str {
         match self {
             TimeZone::Utc(tz) => tz.tzname(dt, fold),
             TimeZone::Offset(tz) => tz.tzname(dt, fold),
@@ -72,9 +125,8 @@ impl TimeZone {
         }
     }
 
-    /// Whether the given wall time is ambiguous (falls in a DST overlap).
     #[inline]
-    pub fn is_ambiguous(&self, dt: NaiveDateTime) -> bool {
+    fn is_ambiguous(&self, dt: NaiveDateTime) -> bool {
         match self {
             TimeZone::Utc(tz) => tz.is_ambiguous(dt),
             TimeZone::Offset(tz) => tz.is_ambiguous(dt),
@@ -83,9 +135,8 @@ impl TimeZone {
         }
     }
 
-    /// Convert a UTC datetime to wall time.
     #[inline]
-    pub fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime {
+    fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime {
         match self {
             TimeZone::Utc(tz) => tz.fromutc(dt),
             TimeZone::Offset(tz) => tz.fromutc(dt),
@@ -93,7 +144,9 @@ impl TimeZone {
             TimeZone::Local(tz) => tz.fromutc(dt),
         }
     }
+}
 
+impl TimeZone {
     /// UTC offset as a `chrono::TimeDelta`.
     #[inline]
     pub fn utcoffset_delta(&self, dt: NaiveDateTime, fold: bool) -> TimeDelta {
@@ -147,8 +200,8 @@ pub(super) const TZPATHS: &[&str] = &[
 const UTC_NAMES: &[&str] = &["UTC", "utc", "GMT", "gmt", "Z", "z"];
 
 /// Thread-safe timezone cache.
-static TZ_CACHE: LazyLock<RwLock<HashMap<Box<str>, TimeZone>>> =
-    LazyLock::new(|| RwLock::new(HashMap::new()));
+static TZ_CACHE: LazyLock<RwLock<FxHashMap<Box<str>, TimeZone>>> =
+    LazyLock::new(|| RwLock::new(FxHashMap::default()));
 
 /// Look up a timezone by name.
 ///
@@ -228,7 +281,7 @@ fn resolve_tz(name: &str) -> Result<TimeZone, TzError> {
 
 /// Check if a wall-clock datetime exists in the given timezone.
 /// Returns `false` for times in DST gaps (spring forward).
-pub fn datetime_exists(dt: NaiveDateTime, tz: &TimeZone) -> bool {
+pub fn datetime_exists(dt: NaiveDateTime, tz: &impl TzOps) -> bool {
     let offset_secs = tz.utcoffset(dt, false) as i64;
     let utc = dt - TimeDelta::seconds(offset_secs);
     let wall = tz.fromutc(utc);
@@ -237,13 +290,13 @@ pub fn datetime_exists(dt: NaiveDateTime, tz: &TimeZone) -> bool {
 
 /// Check if a wall-clock datetime is ambiguous in the given timezone.
 /// Returns `true` for times in DST overlaps (fall back).
-pub fn datetime_ambiguous(dt: NaiveDateTime, tz: &TimeZone) -> bool {
+pub fn datetime_ambiguous(dt: NaiveDateTime, tz: &impl TzOps) -> bool {
     tz.is_ambiguous(dt)
 }
 
 /// Resolve an imaginary datetime (in a DST gap) by shifting forward.
 /// If the datetime already exists, returns it unchanged.
-pub fn resolve_imaginary(dt: NaiveDateTime, tz: &TimeZone) -> NaiveDateTime {
+pub fn resolve_imaginary(dt: NaiveDateTime, tz: &impl TzOps) -> NaiveDateTime {
     if datetime_exists(dt, tz) {
         return dt;
     }

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

@@ -1,6 +1,6 @@
 [package]
 name = "dateutil-py"
-version = "0.1.1"
+version = "0.1.2"
 edition = "2021"
 license = "MIT"
 description = "PyO3 bindings for the dateutil-core crate"
@@ -10,7 +10,7 @@ name = "dateutil_py"
 crate-type = ["rlib"]
 
 [dependencies]
-dateutil-core = { path = "../dateutil-core" }
+dateutil = { path = "../dateutil-core" }
 chrono = "0.4"
 pyo3 = { version = "0.28", features = ["extension-module", "chrono"], optional = true }
 

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/common.rs

@@ -1,8 +1,8 @@
-use dateutil_core::common;
+use dateutil::common;
 use pyo3::prelude::*;
 
-/// Python wrapper for dateutil_core::common::Weekday.
-#[pyclass(name = "weekday", frozen, hash, eq, from_py_object)]
+/// Python wrapper for dateutil::common::Weekday.
+#[pyclass(name = "weekday", frozen, from_py_object)]
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct PyWeekday {
     inner: common::Weekday,
@@ -47,6 +47,34 @@ impl PyWeekday {
         self.inner.n()
     }
 
+    fn __hash__(&self) -> isize {
+        use std::hash::{Hash, Hasher};
+        let mut hasher = std::collections::hash_map::DefaultHasher::new();
+        self.inner.hash(&mut hasher);
+        hasher.finish() as isize
+    }
+
+    fn __eq__(&self, _py: Python<'_>, other: &Bound<'_, PyAny>) -> bool {
+        // Fast path: other is a PyWeekday
+        if let Ok(wd) = other.extract::<PyWeekday>() {
+            return self.inner == wd.inner;
+        }
+        // Duck-type: must have both `weekday` AND `n` attributes
+        let Ok(wd_attr) = other.getattr("weekday") else {
+            return false;
+        };
+        let Ok(n_attr) = other.getattr("n") else {
+            return false;
+        };
+        let Ok(wd_val) = wd_attr.extract::<u8>() else {
+            return false;
+        };
+        let Ok(n_val) = n_attr.extract::<Option<i32>>() else {
+            return false;
+        };
+        self.inner.weekday() == wd_val && self.inner.n() == n_val
+    }
+
     fn __repr__(&self) -> String {
         self.inner.to_string()
     }

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/conv.rs

@@ -148,6 +148,26 @@ pub fn ndt_to_py_datetime_with_fold<'py>(
     )
 }
 
+// ---------------------------------------------------------------------------
+// Scalar-or-sequence extraction helpers
+// ---------------------------------------------------------------------------
+
+/// Accept either a single `i32` or a list of `i32`.
+pub fn extract_i32_list(obj: &Bound<'_, PyAny>) -> PyResult<Vec<i32>> {
+    if let Ok(v) = obj.extract::<i32>() {
+        return Ok(vec![v]);
+    }
+    obj.extract::<Vec<i32>>()
+}
+
+/// Accept either a single `u8` or a list of `u8`.
+pub fn extract_u8_list(obj: &Bound<'_, PyAny>) -> PyResult<Vec<u8>> {
+    if let Ok(v) = obj.extract::<u8>() {
+        return Ok(vec![v]);
+    }
+    obj.extract::<Vec<u8>>()
+}
+
 // ---------------------------------------------------------------------------
 // Timezone / timedelta helpers
 // ---------------------------------------------------------------------------

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/easter.rs

@@ -1,4 +1,4 @@
-use dateutil_core::easter::{self, EasterMethod};
+use dateutil::easter::{self, EasterMethod};
 use pyo3::prelude::*;
 
 /// Python constant values matching python-dateutil convention.

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/parser.rs

@@ -1,8 +1,8 @@
 use std::collections::HashMap;
 
 use super::conv::{make_py_tz, make_py_utc, ndt_to_py_datetime};
-use dateutil_core::parser;
-use dateutil_core::parser::ParserInfo;
+use dateutil::parser;
+use dateutil::parser::ParserInfo;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyTzInfo, PyType};
 

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/relativedelta.rs

@@ -1,12 +1,12 @@
 use super::common::PyWeekday;
 use super::conv;
 use chrono::{Datelike, NaiveDateTime};
-use dateutil_core::common;
-use dateutil_core::relativedelta::{RelativeDelta, RelativeDeltaBuilder};
+use dateutil::common;
+use dateutil::relativedelta::{RelativeDelta, RelativeDeltaBuilder};
 use pyo3::prelude::*;
 use pyo3::types::{PyDate, PyDateTime, PyDelta, PyDeltaAccess, PyTzInfoAccess};
 
-/// Python wrapper for dateutil_core::relativedelta::RelativeDelta.
+/// Python wrapper for dateutil::relativedelta::RelativeDelta.
 #[pyclass(name = "relativedelta", from_py_object)]
 #[derive(Clone, Debug)]
 pub struct PyRelativeDelta {

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/rrule.rs

@@ -1,37 +1,22 @@
 use std::sync::{Arc, Mutex, OnceLock};
 
 use super::common::PyWeekday;
-use dateutil_core::common::Weekday;
-use dateutil_core::rrule::iter::RRuleIter as CoreRRuleIter;
-use dateutil_core::rrule::{
+use super::conv::{extract_i32_list, extract_u8_list, py_any_to_naive_datetime};
+use dateutil::common::Weekday;
+use dateutil::rrule::iter::RRuleIter as CoreRRuleIter;
+use dateutil::rrule::{
     search_after, search_before, search_between,
     Frequency, Recurrence, RRule, RRuleBuilder,
 };
-use dateutil_core::rrule::parse::{rrulestr as core_rrulestr, RRuleStrResult};
-use dateutil_core::rrule::set::{RRuleSet, RRuleSetIter as CoreRRuleSetIter};
+use dateutil::rrule::parse::{rrulestr as core_rrulestr, RRuleStrResult};
+use dateutil::rrule::set::{RRuleSet, RRuleSetIter as CoreRRuleSetIter};
 use pyo3::prelude::*;
 use pyo3::types::{PyAnyMethods, PySlice};
 
 // ---------------------------------------------------------------------------
-// Helpers: accept scalar-or-sequence for by* parameters
+// Helper: accept weekday scalar-or-sequence for byweekday parameter
 // ---------------------------------------------------------------------------
 
-/// Accept either a single `i32` or a list of `i32`.
-fn extract_i32_list(obj: &Bound<'_, PyAny>) -> PyResult<Vec<i32>> {
-    if let Ok(v) = obj.extract::<i32>() {
-        return Ok(vec![v]);
-    }
-    obj.extract::<Vec<i32>>()
-}
-
-/// Accept either a single `u8` or a list of `u8`.
-fn extract_u8_list(obj: &Bound<'_, PyAny>) -> PyResult<Vec<u8>> {
-    if let Ok(v) = obj.extract::<u8>() {
-        return Ok(vec![v]);
-    }
-    obj.extract::<Vec<u8>>()
-}
-
 /// Accept a single weekday/int or a list/tuple of weekday/int and return `Vec<Weekday>`.
 fn extract_byweekday_any(obj: &Bound<'_, PyAny>) -> PyResult<Vec<Weekday>> {
     // Try as a single weekday object
@@ -128,11 +113,11 @@ impl PyRRule {
     fn new(
         py: Python<'_>,
         freq: u8,
-        dtstart: Option<chrono::NaiveDateTime>,
+        dtstart: Option<&Bound<'_, PyAny>>,
         interval: u32,
         wkst: Option<Bound<'_, PyAny>>,
         count: Option<u32>,
-        until: Option<chrono::NaiveDateTime>,
+        until: Option<&Bound<'_, PyAny>>,
         bysetpos: Option<Bound<'_, PyAny>>,
         bymonth: Option<Bound<'_, PyAny>>,
         bymonthday: Option<Bound<'_, PyAny>>,
@@ -149,8 +134,8 @@ impl PyRRule {
             .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
         let mut builder = RRuleBuilder::new(f).interval(interval);
 
-        if let Some(dt) = dtstart {
-            builder = builder.dtstart(dt);
+        if let Some(obj) = dtstart {
+            builder = builder.dtstart(py_any_to_naive_datetime(obj)?);
         }
         if let Some(ref w) = wkst {
             let val = if let Ok(wd) = w.extract::<PyWeekday>() {
@@ -176,8 +161,8 @@ impl PyRRule {
         if let Some(c) = count {
             builder = builder.count(c);
         }
-        if let Some(u) = until {
-            builder = builder.until(u);
+        if let Some(obj) = until {
+            builder = builder.until(py_any_to_naive_datetime(obj)?);
         }
         if let Some(ref v) = bysetpos {
             builder = builder.bysetpos(extract_i32_list(v)?);
@@ -413,6 +398,170 @@ impl PyRRule {
         }
         self.inner.contains(dt)
     }
+
+    /// Return an iterator yielding `count` occurrences after `dt`.
+    #[pyo3(signature = (dt, count=1, inc=false))]
+    fn xafter(
+        &self,
+        dt: chrono::NaiveDateTime,
+        count: usize,
+        inc: bool,
+    ) -> Vec<chrono::NaiveDateTime> {
+        if let Some(cached) = self.get_cache() {
+            let start = if inc {
+                cached.partition_point(|&x| x < dt)
+            } else {
+                cached.partition_point(|&x| x <= dt)
+            };
+            return cached[start..].iter().copied().take(count).collect();
+        }
+        self.inner
+            .iter()
+            .filter(move |&i| if inc { i >= dt } else { i > dt })
+            .take(count)
+            .collect()
+    }
+
+    /// Return a new rrule with specified parameters replaced.
+    #[pyo3(signature = (
+        freq=None,
+        dtstart=None,
+        interval=None,
+        wkst=None,
+        count=None,
+        until=None,
+        bysetpos=None,
+        bymonth=None,
+        bymonthday=None,
+        byyearday=None,
+        byeaster=None,
+        byweekno=None,
+        byweekday=None,
+        byhour=None,
+        byminute=None,
+        bysecond=None,
+        cache=None,
+    ))]
+    #[allow(clippy::too_many_arguments)]
+    fn replace(
+        &self,
+        freq: Option<u8>,
+        dtstart: Option<&Bound<'_, PyAny>>,
+        interval: Option<u32>,
+        wkst: Option<Bound<'_, PyAny>>,
+        count: Option<u32>,
+        until: Option<&Bound<'_, PyAny>>,
+        bysetpos: Option<Bound<'_, PyAny>>,
+        bymonth: Option<Bound<'_, PyAny>>,
+        bymonthday: Option<Bound<'_, PyAny>>,
+        byyearday: Option<Bound<'_, PyAny>>,
+        byeaster: Option<Bound<'_, PyAny>>,
+        byweekno: Option<Bound<'_, PyAny>>,
+        byweekday: Option<Bound<'_, PyAny>>,
+        byhour: Option<Bound<'_, PyAny>>,
+        byminute: Option<Bound<'_, PyAny>>,
+        bysecond: Option<Bound<'_, PyAny>>,
+        cache: Option<bool>,
+    ) -> PyResult<Self> {
+        let f = if let Some(fv) = freq {
+            Frequency::try_from(fv)
+                .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?
+        } else {
+            self.inner.freq()
+        };
+        let mut builder = RRuleBuilder::new(f);
+
+        builder = builder.dtstart(if let Some(obj) = dtstart {
+            py_any_to_naive_datetime(obj)?
+        } else {
+            self.inner.dtstart()
+        });
+
+        builder = builder.interval(interval.unwrap_or_else(|| self.inner.interval()));
+
+        let wkst_val = if let Some(ref w) = wkst {
+            if let Ok(wd) = w.extract::<PyWeekday>() {
+                wd.weekday()
+            } else {
+                w.extract::<u8>()?
+            }
+        } else {
+            self.inner.wkst()
+        };
+        builder = builder.wkst(wkst_val);
+
+        if let Some(c) = count.or(self.inner.count()) {
+            builder = builder.count(c);
+        }
+        if let Some(obj) = until {
+            builder = builder.until(py_any_to_naive_datetime(obj)?);
+        } else if let Some(u) = self.inner.until() {
+            builder = builder.until(u);
+        }
+
+        // by* fields: use provided override, else copy from existing rule
+        if let Some(ref v) = bysetpos {
+            builder = builder.bysetpos(extract_i32_list(v)?);
+        } else if let Some(v) = self.inner.bysetpos() {
+            builder = builder.bysetpos(v.to_vec());
+        }
+        if let Some(ref v) = bymonth {
+            builder = builder.bymonth(extract_u8_list(v)?);
+        } else if let Some(v) = self.inner.bymonth() {
+            builder = builder.bymonth(v.to_vec());
+        }
+        if let Some(ref v) = bymonthday {
+            builder = builder.bymonthday(extract_i32_list(v)?);
+        } else if !self.inner.bymonthday().is_empty() {
+            builder = builder.bymonthday(self.inner.bymonthday().to_vec());
+        }
+        if let Some(ref v) = byyearday {
+            builder = builder.byyearday(extract_i32_list(v)?);
+        } else if let Some(v) = self.inner.byyearday() {
+            builder = builder.byyearday(v.to_vec());
+        }
+        if let Some(ref v) = byeaster {
+            builder = builder.byeaster(extract_i32_list(v)?);
+        } else if let Some(v) = self.inner.byeaster() {
+            builder = builder.byeaster(v.to_vec());
+        }
+        if let Some(ref v) = byweekno {
+            builder = builder.byweekno(extract_i32_list(v)?);
+        } else if let Some(v) = self.inner.byweekno() {
+            builder = builder.byweekno(v.to_vec());
+        }
+        if let Some(ref v) = byweekday {
+            builder = builder.byweekday(extract_byweekday_any(v)?);
+        } else if let Some(v) = self.inner.byweekday() {
+            builder = builder.byweekday(v.to_vec());
+        }
+        if let Some(ref v) = byhour {
+            builder = builder.byhour(extract_u8_list(v)?);
+        } else if let Some(v) = self.inner.byhour() {
+            builder = builder.byhour(v.to_vec());
+        }
+        if let Some(ref v) = byminute {
+            builder = builder.byminute(extract_u8_list(v)?);
+        } else if let Some(v) = self.inner.byminute() {
+            builder = builder.byminute(v.to_vec());
+        }
+        if let Some(ref v) = bysecond {
+            builder = builder.bysecond(extract_u8_list(v)?);
+        } else if let Some(v) = self.inner.bysecond() {
+            builder = builder.bysecond(v.to_vec());
+        }
+
+        let inner = builder
+            .build()
+            .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
+        let cache_val = cache.unwrap_or(self.cache_enabled);
+        let cache_enabled = cache_val && inner.is_finite();
+        Ok(Self {
+            inner,
+            cache_enabled,
+            cache: OnceLock::new(),
+        })
+    }
 }
 
 impl PyRRule {
@@ -874,12 +1023,13 @@ impl PyRRuleSetIter {
 fn rrulestr_py(
     py: Python<'_>,
     s: &str,
-    dtstart: Option<chrono::NaiveDateTime>,
+    dtstart: Option<&Bound<'_, PyAny>>,
     forceset: bool,
     compatible: bool,
     unfold: bool,
     cache: bool,
 ) -> PyResult<Py<PyAny>> {
+    let dtstart = dtstart.map(py_any_to_naive_datetime).transpose()?;
     let result = core_rrulestr(s, dtstart, forceset, compatible, unfold)
         .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?;
     match result {

{python_dateutil_rs-0.1.1 → python_dateutil_rs-0.1.2}/crates/dateutil-py/src/py/tz.rs

@@ -1,5 +1,5 @@
 use chrono::NaiveDateTime;
-use dateutil_core::tz::{self, TimeZone, TzFile, TzLocal, TzOffset, TzUtc};
+use dateutil::tz::{self, TimeZone, TzFile, TzLocal, TzOffset, TzOps};
 use pyo3::prelude::*;
 use pyo3::types::{PyDateTime, PyDelta, PyTzInfo};
 
@@ -315,43 +315,83 @@ fn gettz_py(py: Python<'_>, name: Option<&str>) -> PyResult<Py<PyAny>> {
 
 #[derive(FromPyObject)]
 enum PyTimezone<'py> {
+    #[allow(dead_code)]
     Utc(PyRef<'py, PyTzUtc>),
     Offset(PyRef<'py, PyTzOffset>),
     File(PyRef<'py, PyTzFile>),
     Local(PyRef<'py, PyTzLocal>),
 }
 
-impl PyTimezone<'_> {
-    fn to_timezone(&self) -> TimeZone {
+impl TzOps for PyTimezone<'_> {
+    #[inline]
+    fn utcoffset(&self, dt: NaiveDateTime, fold: bool) -> i32 {
         match self {
-            PyTimezone::Utc(_utc) => TimeZone::Utc(TzUtc),
-            PyTimezone::Offset(tz) => TimeZone::Offset(tz.inner.clone()),
-            PyTimezone::File(tz) => TimeZone::File(tz.inner.clone()),
-            PyTimezone::Local(tz) => TimeZone::Local(tz.inner.clone()),
+            PyTimezone::Utc(_) => 0,
+            PyTimezone::Offset(tz) => tz.inner.offset_seconds(),
+            PyTimezone::File(tz) => tz.inner.utcoffset(dt, fold),
+            PyTimezone::Local(tz) => tz.inner.utcoffset(dt, fold),
+        }
+    }
+
+    #[inline]
+    fn dst(&self, dt: NaiveDateTime, fold: bool) -> i32 {
+        match self {
+            PyTimezone::Utc(_) | PyTimezone::Offset(_) => 0,
+            PyTimezone::File(tz) => tz.inner.dst(dt, fold),
+            PyTimezone::Local(tz) => tz.inner.dst(dt, fold),
+        }
+    }
+
+    #[inline]
+    fn tzname(&self, dt: NaiveDateTime, fold: bool) -> &str {
+        match self {
+            PyTimezone::Utc(_) => "UTC",
+            PyTimezone::Offset(tz) => tz.inner.display_name(),
+            PyTimezone::File(tz) => tz.inner.tzname(dt, fold),
+            PyTimezone::Local(tz) => tz.inner.tzname(dt, fold),
+        }
+    }
+
+    #[inline]
+    fn is_ambiguous(&self, dt: NaiveDateTime) -> bool {
+        match self {
+            PyTimezone::Utc(_) | PyTimezone::Offset(_) => false,
+            PyTimezone::File(tz) => tz.inner.is_ambiguous(dt),
+            PyTimezone::Local(tz) => tz.inner.is_ambiguous(dt),
+        }
+    }
+
+    #[inline]
+    fn fromutc(&self, dt: NaiveDateTime) -> NaiveDateTime {
+        match self {
+            PyTimezone::Utc(_) => dt,
+            PyTimezone::Offset(tz) => tz.inner.fromutc(dt),
+            PyTimezone::File(tz) => tz.inner.fromutc(dt),
+            PyTimezone::Local(tz) => tz.inner.fromutc(dt),
         }
     }
 }
 
 // ---------------------------------------------------------------------------
-// Helper functions
+// Helper functions — zero-clone via TzOps trait
 // ---------------------------------------------------------------------------
 
 #[pyfunction]
 #[pyo3(name = "datetime_exists")]
 fn datetime_exists_py(dt: NaiveDateTime, tz: PyTimezone<'_>) -> bool {
-    tz::datetime_exists(dt, &tz.to_timezone())
+    tz::datetime_exists(dt, &tz)
 }
 
 #[pyfunction]
 #[pyo3(name = "datetime_ambiguous")]
 fn datetime_ambiguous_py(dt: NaiveDateTime, tz: PyTimezone<'_>) -> bool {
-    tz::datetime_ambiguous(dt, &tz.to_timezone())
+    tz::datetime_ambiguous(dt, &tz)
 }
 
 #[pyfunction]
 #[pyo3(name = "resolve_imaginary")]
 fn resolve_imaginary_py(dt: NaiveDateTime, tz: PyTimezone<'_>) -> NaiveDateTime {
-    tz::resolve_imaginary(dt, &tz.to_timezone())
+    tz::resolve_imaginary(dt, &tz)
 }
 
 // ---------------------------------------------------------------------------

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

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

python_dateutil_rs-0.1.1/crates/dateutil-core/Cargo.toml

@@ -1,25 +0,0 @@
-[package]
-name = "dateutil-core"
-version = "0.1.1"
-edition = "2021"
-license = "MIT"
-description = "Performance-optimized date utility library for Rust"
-
-[lib]
-name = "dateutil_core"
-crate-type = ["rlib"]
-
-[dependencies]
-bitflags = "2"
-chrono = "0.4"
-phf = { version = "0.13", features = ["macros"] }
-smallvec = "1.15"
-thiserror = "2"
-iana-time-zone = "0.1"
-
-[dev-dependencies]
-criterion = { version = "0.8", features = ["html_reports"] }
-
-[[bench]]
-name = "benchmarks"
-harness = false