refactor(numpydates): simplify date and time delta conversions with rescale function

- Add pyconvert rules for InlineDateTime64 and InlineTimeDelta64 types
- Refactor DateTime64 and TimeDelta64 constructors to use rescale for unit conversions
- Introduce unitscale and rescale functions in Unit.jl for efficient scaling between units
- Add convert methods for DatesInstant and DatesPeriod types
- Update common.jl with new type aliases and helper functions
- Enhance tests for new conversion capabilities and error handling

These changes streamline the conversion logic, reduce code duplication, and improve performance by centralizing unit scaling operations. No breaking changes to public APIs.

Author: Christopher Doris

src/Convert/numpy.jl

@@ -13,6 +13,10 @@ function pyconvert_rule_datetime64(::Type{DateTime64}, x::Py)
     pyconvert_return(C.PySimpleObject_GetValue(DateTime64, x))
 end
 
+function pyconvert_rule_datetime64(::Type{T}, x::Py) where {T<:InlineDateTime64}
+    pyconvert_return(T(C.PySimpleObject_GetValue(DateTime64, x)))
+end
+
 function pyconvert_rule_datetime64(::Type{DateTime}, x::Py)
     d = C.PySimpleObject_GetValue(DateTime64, x)
     if isnan(d)
@@ -44,6 +48,10 @@ function pyconvert_rule_timedelta64(::Type{TimeDelta64}, x::Py)
     pyconvert_return(C.PySimpleObject_GetValue(TimeDelta64, x))
 end
 
+function pyconvert_rule_datetime64(::Type{T}, x::Py) where {T<:InlineTimeDelta64}
+    pyconvert_return(T(C.PySimpleObject_GetValue(TimeDelta64, x)))
+end
+
 function pyconvert_rule_timedelta64(::Type{Missing}, x::Py)
     d = C.PySimpleObject_GetValue(TimeDelta64, x)
     if isnan(d)
@@ -116,6 +124,7 @@ function init_numpy()
         pyconvert_rule_datetime64,
         PYCONVERT_PRIORITY_ARRAY,
     )
+    pyconvert_add_rule("numpy:datetime64", InlineDateTime64, pyconvert_rule_datetime64)
     pyconvert_add_rule("numpy:datetime64", DateTime, pyconvert_rule_datetime64)
     pyconvert_add_rule("numpy:datetime64", Missing, pyconvert_rule_datetime64)
     pyconvert_add_rule("numpy:datetime64", Nothing, pyconvert_rule_datetime64)
@@ -127,6 +136,7 @@ function init_numpy()
         pyconvert_rule_timedelta64,
         PYCONVERT_PRIORITY_ARRAY,
     )
+    pyconvert_add_rule("numpy:timedelta64", InlineTimeDelta64, pyconvert_rule_timedelta64)
     pyconvert_add_rule("numpy:timedelta64", Missing, pyconvert_rule_timedelta64)
     pyconvert_add_rule("numpy:timedelta64", Nothing, pyconvert_rule_timedelta64)
 end

src/NumpyDates/AbstractDateTime64.jl

@@ -5,44 +5,17 @@ Supertype for [`DateTime64`](@ref) and [`InlineDateTime64`](@ref).
 """
 abstract type AbstractDateTime64 <: Dates.TimeType end
 
-function Dates.value(d::AbstractDateTime64)
-    d.value
-end
-
 function Dates.DateTime(d::AbstractDateTime64)
     isnan(d) && error("Cannot convert NaT to DateTime")
     v = value(d)
-    u, s = unitpair(d)
-    v = v * s  # TODO: check overflow
+    u, _ = unit = unitpair(d)
     b = Dates.DateTime(1970)
-    if u == YEARS
-        b + Dates.Year(v)
-    elseif u == MONTHS
-        b + Dates.Month(v)
-    elseif u == WEEKS
-        b + Dates.Week(v)
-    elseif u == DAYS
-        b + Dates.Day(v)
-    elseif u == HOURS
-        b + Dates.Hour(v)
-    elseif u == MINUTES
-        b + Dates.Minute(v)
-    elseif u == SECONDS
-        b + Dates.Second(v)
-    elseif u == MILLISECONDS
+    if u > MONTHS
+        v, _ = rescale(v, unit, MILLISECONDS)
         b + Dates.Millisecond(v)
-    elseif u == MICROSECONDS
-        b + Dates.Microsecond(v)
-    elseif u == NANOSECONDS
-        b + Dates.Nanosecond(v)
-    elseif u == PICOSECONDS
-        b + Dates.Nanosecond(fld(v, 1_000))
-    elseif u == FEMTOSECONDS
-        b + Dates.Nanosecond(fld(v, 1_000_000))
-    elseif u == ATTOSECONDS
-        b + Dates.Nanosecond(fld(v, 1_000_000_000))
     else
-        error("Unsupported units: $unit_base")
+        v, _ = rescale(v, unit, MONTHS)
+        b + Dates.Month(v)
     end
 end
 
@@ -51,6 +24,9 @@ function Dates.Date(d::AbstractDateTime64)
     Dates.Date(Dates.DateTime(d))
 end
 
+Base.convert(::Type{Dates.DateTime}, d::AbstractDateTime64) = Dates.DateTime(d)
+Base.convert(::Type{Dates.Date}, d::AbstractDateTime64) = Dates.Date(d)
+
 function Base.isnan(d::AbstractDateTime64)
     value(d) == typemin(Int64)
 end

src/NumpyDates/AbstractTimeDelta64.jl

@@ -5,6 +5,32 @@ Supertype for [`TimeDelta64`](@ref) and [`InlineTimeDelta64`](@ref).
 """
 abstract type AbstractTimeDelta64 <: Dates.Period end
 
+function construct(::Type{T}, d::AbstractTimeDelta64) where {T<:DatesPeriod}
+    v, r = rescale(value(d), unitpair(d), Unit(T))
+    iszero(r) || throw(InexactError(nameof(T), T, d))
+    T(v)
+end
+
+Dates.Year(d::AbstractTimeDelta64) = construct(Dates.Year, d)
+Dates.Month(d::AbstractTimeDelta64) = construct(Dates.Month, d)
+Dates.Day(d::AbstractTimeDelta64) = construct(Dates.Day, d)
+Dates.Hour(d::AbstractTimeDelta64) = construct(Dates.Hour, d)
+Dates.Minute(d::AbstractTimeDelta64) = construct(Dates.Minute, d)
+Dates.Second(d::AbstractTimeDelta64) = construct(Dates.Second, d)
+Dates.Millisecond(d::AbstractTimeDelta64) = construct(Dates.Millisecond, d)
+Dates.Microsecond(d::AbstractTimeDelta64) = construct(Dates.Microsecond, d)
+Dates.Nanosecond(d::AbstractTimeDelta64) = construct(Dates.Nanosecond, d)
+
+Base.convert(::Type{Dates.Year}, d::AbstractTimeDelta64) = Dates.Year(d)
+Base.convert(::Type{Dates.Month}, d::AbstractTimeDelta64) = Dates.Month(d)
+Base.convert(::Type{Dates.Day}, d::AbstractTimeDelta64) = Dates.Day(d)
+Base.convert(::Type{Dates.Hour}, d::AbstractTimeDelta64) = Dates.Hour(d)
+Base.convert(::Type{Dates.Minute}, d::AbstractTimeDelta64) = Dates.Minute(d)
+Base.convert(::Type{Dates.Second}, d::AbstractTimeDelta64) = Dates.Second(d)
+Base.convert(::Type{Dates.Millisecond}, d::AbstractTimeDelta64) = Dates.Millisecond(d)
+Base.convert(::Type{Dates.Microsecond}, d::AbstractTimeDelta64) = Dates.Microsecond(d)
+Base.convert(::Type{Dates.Nanosecond}, d::AbstractTimeDelta64) = Dates.Nanosecond(d)
+
 function Base.isnan(d::AbstractTimeDelta64)
     value(d) == NAT
 end

src/NumpyDates/DateTime64.jl

@@ -70,75 +70,29 @@ function DateTime64(d::AbstractString, f::Dates.DateFormat, unit::UnitArg = defa
 end
 
 function DateTime64(d::Dates.DateTime, unit::UnitArg = defaultunit(d))
-    u, m = unit = unitpair(unit)
-    if u ≤ DAYS
-        return DateTime64(Dates.Date(d), unit)
-    end
-    v = value((d - Dates.DateTime(1970))::Dates.Millisecond)
-    if u == HOURS
-        m = mul(m, 1000 * 60 * 60)
-    elseif u == MINUTES
-        m = mul(m, 1000 * 60)
-    elseif u == SECONDS
-        m = mul(m, 1000)
-    elseif u == MILLISECONDS
-        # nothing
-    elseif u == MICROSECONDS
-        v = mul(v, 1000)
-    elseif u == NANOSECONDS
-        v = mul(v, 1000_000)
-    elseif u == PICOSECONDS
-        v = mul(v, 1000_000_000)
-    elseif u == FEMTOSECONDS
-        v = mul(v, 1000_000_000_000)
-    elseif u == ATTOSECONDS
-        v = mul(v, 1000_000_000_000_000)
+    u, _ = unit = unitpair(unit)
+    if u == YEARS
+        v_yr = sub(Dates.year(d), 1970)
+        v, _ = rescale(v_yr, YEARS, unit)
+    elseif u == MONTHS
+        yr, mn = Dates.yearmonth(d)
+        v_mn = add(mul(12, sub(yr, 1970)), sub(mn, 1))
+        v, _ = rescale(v_mn, MONTHS, unit)
     else
-        error("unknown unit: $u")
+        v_ms = d - Dates.DateTime(1970)
+        v, _ = rescale(value(v_ms), Unit(v_ms), unit)
     end
-    v = fld(v, m)
     DateTime64(v, unit)
 end
 
 
 function DateTime64(d::Dates.Date, unit::UnitArg = defaultunit(d))
-    u, m = unit = unitpair(unit)
-    if u == YEARS
-        v = Dates.year(d) - 1970
-    elseif u == MONTHS
-        v = 12 * (Dates.year(d) - 1970) + (Dates.month(d) - 1)
-    else
-        v = value((d - Dates.Date(1970))::Dates.Day)
-        if u == WEEKS
-            m = mul(m, 7)
-        elseif u == DAYS
-            # nothing
-        elseif u == HOURS
-            v = mul(v, 24)
-        elseif u == MINUTES
-            v = mul(v, 24 * 60)
-        elseif u == SECONDS
-            v = mul(v, 24 * 60 * 60)
-        elseif u == MILLISECONDS
-            v = mul(v, 24 * 60 * 60 * 1000)
-        elseif u == MICROSECONDS
-            v = mul(v, 24 * 60 * 60 * 1000_000)
-        elseif u == NANOSECONDS
-            v = mul(v, 24 * 60 * 60 * 1000_000_000)
-        elseif u == PICOSECONDS
-            v = mul(v, 24 * 60 * 60 * 1000_000_000_000)
-        elseif u == FEMTOSECONDS
-            throw(OverflowError(""))
-        elseif u == ATTOSECONDS
-            throw(OverflowError(""))
-        else
-            error("unknown unit: $u")
-        end
-    end
-    v = fld(v, m)
-    DateTime64(v, unit)
+    DateTime64(Dates.DateTime(d), unit)
 end
 
+# convert
+
+Base.convert(::Type{DateTime64}, x::DatesInstant) = DateTime64(x)
 
 # show
 

src/NumpyDates/InlineDateTime64.jl

@@ -94,6 +94,12 @@ function InlineDateTime64(
     InlineTimeDelta64{unitparam(u)}(v, f)
 end
 
+# convert
+
+Base.convert(::Type{InlineDateTime64}, x::DatesInstant) = InlineDateTime64(x)
+Base.convert(::Type{InlineDateTime64{U}}, x::DatesInstant) where {U} =
+    InlineDateTime64{U}(x)
+
 # show
 
 function Base.show(io::IO, d::InlineDateTime64)

src/NumpyDates/InlineTimeDelta64.jl

@@ -42,7 +42,7 @@ function InlineTimeDelta64{U}(v::AbstractString) where {U}
     InlineTimeDelta64{U}(value(TimeDelta64(v, U)))
 end
 
-function InlineTimeDelta64{U}(v::Dates.Period) where {U}
+function InlineTimeDelta64{U}(v::DatesPeriod) where {U}
     InlineTimeDelta64{U}(value(TimeDelta64(v, U)))
 end
 
@@ -58,14 +58,20 @@ function InlineTimeDelta64(v::AbstractString, u::UnitArg = defaultunit(v))
     InlineTimeDelta64{unitparam(u)}(v)
 end
 
-function InlineTimeDelta64(v::Dates.Period, u::UnitArg = defaultunit(v))
+function InlineTimeDelta64(v::DatesPeriod, u::UnitArg = defaultunit(v))
     InlineTimeDelta64{unitparam(u)}(v)
 end
 
 function InlineTimeDelta64(v::Integer, u::UnitArg)
     InlineTimeDelta64{unitparam(u)}(v)
 end
 
+# convert
+
+Base.convert(::Type{InlineTimeDelta64}, p::DatesPeriod) = InlineTimeDelta64(p)
+Base.convert(::Type{InlineTimeDelta64{U}}, p::DatesPeriod) where {U} =
+    InlineTimeDelta64{U}(p)
+
 # show
 
 function Base.show(io::IO, d::InlineTimeDelta64)
@@ -79,3 +85,5 @@ function Base.show(io::IO, d::InlineTimeDelta64)
     end
     nothing
 end
+
+Base.show(io::IO, ::MIME"text/plain", d::InlineTimeDelta64) = show(io, d)

src/NumpyDates/TimeDelta64.jl

@@ -59,90 +59,15 @@ function TimeDelta64(s::AbstractString, unit::UnitArg = defaultunit(s))
     end
 end
 
-# Convert Dates.Period to TimeDelta64
-function TimeDelta64(p::Dates.Period, unit::UnitArg = defaultunit(p))
-    u, m = unitpair(unit)
-    if u == YEARS
-        if p isa Dates.Year
-            v = value(p)
-            return TimeDelta64(fld(v, m), unit)
-        else
-            error("cannot convert $(typeof(p)) to years")
-        end
-    elseif u == MONTHS
-        if p isa Dates.Month
-            v = value(p)
-            return TimeDelta64(fld(v, m), unit)
-        elseif p isa Dates.Year
-            v = mul(value(p), 12)
-            return TimeDelta64(fld(v, m), unit)
-        else
-            error("cannot convert $(typeof(p)) to months")
-        end
-    elseif u == PICOSECONDS || u == FEMTOSECONDS || u == ATTOSECONDS
-        # sub-nanosecond units: expand from ns
-        ns = _period_to_ns(p)
-        scale = u == PICOSECONDS ? 1_000 : u == FEMTOSECONDS ? 1_000_000 : 1_000_000_000
-        ns_scaled = mul(ns, scale)
-        return TimeDelta64(fld(ns_scaled, m), unit)
-    else
-        # weeks..nanoseconds: convert via nanoseconds
-        ns = _period_to_ns(p)
-        unit_ns = _unit_to_ns(u)
-        denom = mul(unit_ns, Int64(m))
-        return TimeDelta64(fld(ns, denom), unit)
-    end
+function TimeDelta64(p::DatesPeriod, unit::UnitArg = defaultunit(p))
+    v, r = rescale(value(p), Unit(p), unit)
+    iszero(r) || throw(InexactError(:TimeDelta64, TimeDelta64, p, unit))
+    TimeDelta64(v, unit)
 end
 
-# helpers
-
-# number of nanoseconds per unit (except sub-ns which are handled separately)
-function _unit_to_ns(u::Unit)::Int64
-    if u == WEEKS
-        mul(mul(mul(mul(Int64(7), Int64(24)), Int64(60)), Int64(60)), Int64(1_000_000_000))
-    elseif u == DAYS
-        mul(mul(mul(Int64(24), Int64(60)), Int64(60)), Int64(1_000_000_000))
-    elseif u == HOURS
-        mul(mul(Int64(60), Int64(60)), Int64(1_000_000_000))
-    elseif u == MINUTES
-        mul(Int64(60), Int64(1_000_000_000))
-    elseif u == SECONDS
-        Int64(1_000_000_000)
-    elseif u == MILLISECONDS
-        Int64(1_000_000)
-    elseif u == MICROSECONDS
-        Int64(1_000)
-    elseif u == NANOSECONDS
-        Int64(1)
-    else
-        error("Unsupported or sub-nanosecond unit for ns mapping: $u")
-    end
-end
+# convert
 
-# convert a Dates.Period into total nanoseconds (disallow calendar Year/Month here)
-function _period_to_ns(p::Dates.Period)::Int64
-    if p isa Dates.Week
-        mul(value(p), _unit_to_ns(WEEKS))
-    elseif p isa Dates.Day
-        mul(value(p), _unit_to_ns(DAYS))
-    elseif p isa Dates.Hour
-        mul(value(p), _unit_to_ns(HOURS))
-    elseif p isa Dates.Minute
-        mul(value(p), _unit_to_ns(MINUTES))
-    elseif p isa Dates.Second
-        mul(value(p), _unit_to_ns(SECONDS))
-    elseif p isa Dates.Millisecond
-        mul(value(p), _unit_to_ns(MILLISECONDS))
-    elseif p isa Dates.Microsecond
-        mul(value(p), _unit_to_ns(MICROSECONDS))
-    elseif p isa Dates.Nanosecond
-        value(p)
-    elseif p isa Dates.Month || p isa Dates.Year
-        error("cannot convert $(typeof(p)) to time-based units")
-    else
-        error("unsupported period type: $(typeof(p))")
-    end
-end
+Base.convert(::Type{TimeDelta64}, p::DatesPeriod) = TimeDelta64(p)
 
 # show
 
@@ -159,3 +84,5 @@ function Base.show(io::IO, d::TimeDelta64)
     end
     nothing
 end
+
+Base.show(io::IO, ::MIME"text/plain", d::TimeDelta64) = show(io, d)