refactor(numpydates): add rescale support and expand convert methods for datetime64 and timedelta64

- Implement rescale function to handle unit changes in DateTime64 and TimeDelta64 instead of throwing errors
- Expand Base.convert methods for InlineDateTime64 and InlineTimeDelta64 to support more types
- Add new pyconvert rules for NumpyDates.DatesInstant and NumpyDates.DatesPeriod in numpy.jl

This enhances type conversions and removes previous limitations on unit scaling.

Author: Christopher Doris

src/Convert/numpy.jl

@@ -14,15 +14,15 @@ function pyconvert_rule_datetime64(::Type{DateTime64}, x::Py)
 end
 
 function pyconvert_rule_datetime64(::Type{T}, x::Py) where {T<:InlineDateTime64}
-    pyconvert_return(T(C.PySimpleObject_GetValue(DateTime64, x)))
+    pyconvert_tryconvert(T, C.PySimpleObject_GetValue(DateTime64, x))
 end
 
-function pyconvert_rule_datetime64(::Type{DateTime}, x::Py)
+function pyconvert_rule_datetime64(::Type{T}, x::Py) where {T<:NumpyDates.DatesInstant}
     d = C.PySimpleObject_GetValue(DateTime64, x)
     if isnan(d)
         pyconvert_unconverted()
     else
-        pyconvert_tryconvert(DateTime, d)
+        pyconvert_tryconvert(T, d)
     end
 end
 
@@ -48,8 +48,17 @@ 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)))
+function pyconvert_rule_timedelta64(::Type{T}, x::Py) where {T<:InlineTimeDelta64}
+    pyconvert_tryconvert(T, C.PySimpleObject_GetValue(TimeDelta64, x))
+end
+
+function pyconvert_rule_timedelta64(::Type{T}, x::Py) where {T<:NumpyDates.DatesPeriod}
+    d = C.PySimpleObject_GetValue(TimeDelta64, x)
+    if isnan(d)
+        pyconvert_unconverted()
+    else
+        pyconvert_tryconvert(T, d)
+    end
 end
 
 function pyconvert_rule_timedelta64(::Type{Missing}, x::Py)
@@ -125,7 +134,11 @@ function init_numpy()
         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",
+        NumpyDates.DatesInstant,
+        pyconvert_rule_datetime64,
+    )
     pyconvert_add_rule("numpy:datetime64", Missing, pyconvert_rule_datetime64)
     pyconvert_add_rule("numpy:datetime64", Nothing, pyconvert_rule_datetime64)
 
@@ -137,6 +150,11 @@ function init_numpy()
         PYCONVERT_PRIORITY_ARRAY,
     )
     pyconvert_add_rule("numpy:timedelta64", InlineTimeDelta64, pyconvert_rule_timedelta64)
+    pyconvert_add_rule(
+        "numpy:timedelta64",
+        NumpyDates.DatesPeriod,
+        pyconvert_rule_timedelta64,
+    )
     pyconvert_add_rule("numpy:timedelta64", Missing, pyconvert_rule_timedelta64)
     pyconvert_add_rule("numpy:timedelta64", Nothing, pyconvert_rule_timedelta64)
 end

src/NumpyDates/DateTime64.jl

@@ -45,9 +45,8 @@ function DateTime64(d::AbstractDateTime64, unit::UnitArg = defaultunit(d))
     elseif isnan(d)
         DateTime64(NAT, unit)
     else
-        error(
-            "not implemented: changing units: $(unitparam(unitpair(d))) to $(unitparam(unit))",
-        )
+        v, _ = rescale(value(d), unitpair(d), unit)
+        DateTime64(v, unit)
     end
 end
 
@@ -92,6 +91,8 @@ end
 
 # convert
 
+Base.convert(::Type{DateTime64}, x::DateTime64) = x
+Base.convert(::Type{DateTime64}, x::AbstractDateTime64) = DateTime64(x)
 Base.convert(::Type{DateTime64}, x::DatesInstant) = DateTime64(x)
 
 # show

src/NumpyDates/InlineDateTime64.jl

@@ -96,9 +96,14 @@ end
 
 # convert
 
-Base.convert(::Type{InlineDateTime64}, x::DatesInstant) = InlineDateTime64(x)
-Base.convert(::Type{InlineDateTime64{U}}, x::DatesInstant) where {U} =
-    InlineDateTime64{U}(x)
+Base.convert(::Type{InlineDateTime64}, x::InlineDateTime64) = x
+Base.convert(::Type{InlineDateTime64}, x::Union{AbstractDateTime64,DatesInstant}) =
+    InlineDateTime64(x)
+Base.convert(::Type{InlineDateTime64{U}}, x::InlineDateTime64{U}) where {U} = x
+Base.convert(
+    ::Type{InlineDateTime64{U}},
+    x::Union{AbstractDateTime64,DatesInstant},
+) where {U} = InlineDateTime64{U}(x)
 
 # show
 

src/NumpyDates/InlineTimeDelta64.jl

@@ -68,9 +68,14 @@ end
 
 # convert
 
-Base.convert(::Type{InlineTimeDelta64}, p::DatesPeriod) = InlineTimeDelta64(p)
-Base.convert(::Type{InlineTimeDelta64{U}}, p::DatesPeriod) where {U} =
-    InlineTimeDelta64{U}(p)
+Base.convert(::Type{InlineTimeDelta64}, p::InlineTimeDelta64) = p
+Base.convert(::Type{InlineTimeDelta64}, p::Union{AbstractTimeDelta64,DatesPeriod}) =
+    InlineTimeDelta64(p)
+Base.convert(::Type{InlineTimeDelta64{U}}, p::InlineTimeDelta64{U}) where {U} = p
+Base.convert(
+    ::Type{InlineTimeDelta64{U}},
+    p::Union{AbstractTimeDelta64,DatesPeriod},
+) where {U} = InlineTimeDelta64{U}(p)
 
 # show
 

src/NumpyDates/TimeDelta64.jl

@@ -42,9 +42,9 @@ function TimeDelta64(d::AbstractTimeDelta64, unit::UnitArg = defaultunit(d))
     elseif isnan(d)
         TimeDelta64(NAT, unit)
     else
-        error(
-            "not implemented: changing units: $(unitparam(unitpair(d))) to $(unitparam(unit))",
-        )
+        v, r = rescale(value(d), unitpair(d), unit)
+        iszero(r) || throw(InexactError(:TimeDelta64, TimeDelta64, d, unit))
+        TimeDelta64(v, unit)
     end
 end
 
@@ -67,7 +67,9 @@ end
 
 # convert
 
-Base.convert(::Type{TimeDelta64}, p::DatesPeriod) = TimeDelta64(p)
+Base.convert(::Type{TimeDelta64}, p::TimeDelta64) = p
+Base.convert(::Type{TimeDelta64}, p::Union{AbstractTimeDelta64,DatesPeriod}) =
+    TimeDelta64(p)
 
 # show