Add timedelta, timedelta64 and datetime64 plus respective conversions

src/Convert/Convert.jl

@@ -45,6 +45,7 @@ using ..Core:
     pythrow,
     pybool_asbool
 using Dates: Date, Time, DateTime, Second, Millisecond, Microsecond, Nanosecond
+using Dates: Year, Month, Day, Hour, Minute, Week, Period, CompoundPeriod, canonicalize
 
 import ..Core: pyconvert
 

src/Convert/numpy.jl

@@ -27,6 +27,66 @@ const NUMPY_SIMPLE_TYPES = [
     ("complex128", ComplexF64),
 ]
 
+function pydatetime64(
+    _year::Int=0, _month::Int=1, _day::Int=1, _hour::Int=0, _minute::Int=0,_second::Int=0, _millisecond::Int=0, _microsecond::Int=0, _nanosecond::Int=0;
+    year::Int=_year, month::Int=_month, day::Int=_day, hour::Int=_hour, minute::Int=_minute, second::Int=_second,
+    millisecond::Int=_millisecond, microsecond::Int=_microsecond, nanosecond::Int=_nanosecond
+)
+    pyimport("numpy").datetime64("$(DateTime(year, month, day, hour, minute, second))") + pytimedelta64(;millisecond, microsecond, nanosecond)
+end
+function pydatetime64(@nospecialize(x::T)) where T <: Period
+    T <: Union{Week, Day, Hour, Minute, Second, Millisecond, Microsecond} || 
+        error("Unsupported Period type: ", "Year, Month and Nanosecond are not supported, consider using pytimedelta64 instead.")
+    args = T .== (Day, Second, Millisecond, Microsecond,  Minute, Hour, Week)
+    pydatetime64(x.value .* args...)
+end
+function pydatetime64(x::CompoundPeriod)
+    x =  canonicalize(x)
+    isempty(x.periods) ? pydatetime64(Second(0)) : sum(pydatetime64.(x.periods))
+end
+export pydatetime64
+
+function pytimedelta64(
+    _year::Int=0, _month::Int=0, _day::Int=0, _hour::Int=0, _minute::Int=0, _second::Int=0, _millisecond::Int=0, _microsecond::Int=0, _nanosecond::Int=0, _week::Int=0;
+    year::Int=_year, month::Int=_month, day::Int=_day, hour::Int=_hour, minute::Int=_minute, second::Int=_second, microsecond::Int=_microsecond, millisecond::Int=_millisecond, nanosecond::Int=_nanosecond, week::Int=_week)
+    pytimedelta64(sum((
+        Year(year), Month(month), # you cannot mix year or month with any of the below units in python, the error will be thrown by `pytimedelta64(::CompoundPeriod)`
+        Day(day), Hour(hour), Minute(minute), Second(second), Millisecond(millisecond), Microsecond(microsecond), Nanosecond(nanosecond), Week(week))
+    ))
+end
+function pytimedelta64(@nospecialize(x::T)) where T <: Period
+    index = findfirst(==(T), (Year, Month, Week, Day, Hour, Minute, Second, Millisecond, Microsecond, Nanosecond, T))
+    unit = ("Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns", "")[index]
+    pyimport("numpy").timedelta64(x.value, unit)
+end
+function pytimedelta64(x::CompoundPeriod)
+    x =  canonicalize(x)
+    isempty(x.periods) ? pytimedelta64(Second(0)) : sum(pytimedelta64.(x.periods))
+end
+export pytimedelta64
+
+function pyconvert_rule_datetime64(::Type{DateTime}, x::Py)
+    unit, count = pyconvert(Tuple, pyimport("numpy").datetime_data(x))
+    value = reinterpret(Int64, pyconvert(Vector, x))[1]
+    units = ("Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns")
+    types = (Year, Month, Week, Day, Hour, Minute, Second, Millisecond, Microsecond, Nanosecond)
+    T = types[findfirst(==(unit), units)]
+    pyconvert_return(DateTime(_base_datetime) + T(value * count))
+end
+
+function pyconvert_rule_timedelta64(::Type{CompoundPeriod}, x::Py)
+    unit, count = pyconvert(Tuple, pyimport("numpy").datetime_data(x))
+    value = reinterpret(Int64, pyconvert(Vector, x))[1]
+    units = ("Y", "M", "W", "D", "h", "m", "s", "ms", "us", "ns")
+    types = (Year, Month, Week, Day, Hour, Minute, Second, Millisecond, Microsecond, Nanosecond)
+    T = types[findfirst(==(unit), units)]
+    pyconvert_return(CompoundPeriod(T(value * count)) |> canonicalize)
+end
+
+function pyconvert_rule_timedelta64(::Type{T}, x::Py) where T<:Period
+    pyconvert_return(convert(T, pyconvert_rule_timedelta64(CompoundPeriod, x)))
+end
+
 function init_numpy()
     for (t, T) in NUMPY_SIMPLE_TYPES
         isbool = occursin("bool", t)
@@ -54,4 +114,14 @@ function init_numpy()
         iscomplex && pyconvert_add_rule(name, Complex, rule)
         isnumber && pyconvert_add_rule(name, Number, rule)
     end
+
+    priority = PYCONVERT_PRIORITY_ARRAY
+    pyconvert_add_rule("numpy:datetime64", DateTime, pyconvert_rule_datetime64, priority)
+    for T in (CompoundPeriod, Year, Month, Day, Hour, Minute, Second, Millisecond, Microsecond, Nanosecond, Week)
+        pyconvert_add_rule("numpy:timedelta64", T, pyconvert_rule_timedelta64, priority)
+    end
+
+    priority = PYCONVERT_PRIORITY_CANONICAL
+    pyconvert_add_rule("numpy:datetime64", DateTime, pyconvert_rule_datetime64, priority)
+    pyconvert_add_rule("numpy:timedelta64", Nanosecond, pyconvert_rule_timedelta, priority)    
 end

src/Convert/pyconvert.jl

@@ -428,6 +428,12 @@ function init_pyconvert()
         pyimport("collections.abc" => ("Iterable", "Sequence", "Set", "Mapping"))...,
     )
 
+    priority = PYCONVERT_PRIORITY_ARRAY
+    pyconvert_add_rule("datetime:datetime", DateTime, pyconvert_rule_datetime, priority)
+    for T in (Millisecond, Second, Nanosecond, Day, Hour, Minute, Second, Millisecond, Week, CompoundPeriod)
+        pyconvert_add_rule("datetime:timedelta", T, pyconvert_rule_timedelta, priority)
+    end
+
     priority = PYCONVERT_PRIORITY_CANONICAL
     pyconvert_add_rule("builtins:NoneType", Nothing, pyconvert_rule_none, priority)
     pyconvert_add_rule("builtins:bool", Bool, pyconvert_rule_bool, priority)

src/Convert/rules.jl

@@ -512,3 +512,16 @@ function pyconvert_rule_timedelta(::Type{Second}, x::Py)
     end
     return Second(days * 3600 * 24 + seconds)
 end
+
+function pyconvert_rule_timedelta(::Type{<:CompoundPeriod}, x::Py)
+    days = pyconvert(Int, x.days)
+    seconds = pyconvert(Int, x.seconds)
+    microseconds = pyconvert(Int, x.microseconds)
+    nanoseconds = pyhasattr(x, "nanoseconds") ? pyconvert(Int, x.nanoseconds) : 0
+    timedelta = Day(days) + Second(seconds) + Microsecond(microseconds) + Nanosecond(nanoseconds)
+    return pyconvert_return(timedelta)
+end
+
+function pyconvert_rule_timedelta(::Type{T}, x::Py) where T<:Period
+    pyconvert_return(convert(T, pyconvert_rule_timedelta(CompoundPeriod, x)))
+end

src/Core/Core.jl

@@ -25,7 +25,17 @@ using Dates:
     second,
     millisecond,
     microsecond,
-    nanosecond
+    nanosecond,
+    Day,
+    Hour,
+    Week,
+    Minute,
+    Second,
+    Millisecond,
+    Microsecond,
+    Period,
+    CompoundPeriod,
+    canonicalize
 using MacroTools: MacroTools, @capture
 using Markdown: Markdown
 

src/Core/Py.jl

@@ -158,6 +158,7 @@ Py(
 Py(x::Date) = pydate(x)
 Py(x::Time) = pytime(x)
 Py(x::DateTime) = pydatetime(x)
+Py(x::Union{Period, CompoundPeriod}) = pytimedelta(x)
 
 Base.string(x::Py) = pyisnull(x) ? "<py NULL>" : pystr(String, x)
 Base.print(io::IO, x::Py) = print(io, string(x))

src/Core/builtins.jl

@@ -1167,6 +1167,24 @@ end
 pydatetime(x::Date) = pydatetime(year(x), month(x), day(x))
 export pydatetime
 
+function pytimedelta(
+    _day::Int=0, _second::Int=0, _microsecond::Int=0, _millisecond::Int=0, _minute::Int=0, _hour::Int=0, _week::Int=0;
+    day::Int=_day, second::Int=_second, microsecond::Int=_microsecond, millisecond::Int=_millisecond, minute::Int=_minute, hour::Int=_hour, week::Int=_week
+)
+    pyimport("datetime").timedelta(day, second, microsecond, millisecond, minute, hour, week)
+end
+function pytimedelta(@nospecialize(x::T)) where T <: Period
+    T <: Union{Week, Day, Hour, Minute, Second, Millisecond, Microsecond} || 
+        error("Unsupported Period type: ", "Year, Month and Nanosecond are not supported, consider using pytimedelta64 instead.")
+    args = T .== (Day, Second, Millisecond, Microsecond, Minute, Hour, Week)
+    pytimedelta(x.value .* args...)
+end
+function pytimedelta(x::CompoundPeriod)
+    x =  canonicalize(x)
+    isempty(x.periods) ? pytimedelta(Second(0)) : sum(pytimedelta.(x.periods))
+end
+export pytimedelta
+
 function pytime_isaware(x)
     tzinfo = pygetattr(x, "tzinfo")
     if pyisnone(tzinfo)

src/PyMacro/PyMacro.jl

@@ -886,6 +886,9 @@ For example:
 - `import x: f as g` is translated to `g = pyimport("x" => "f")` (`from x import f as g` in Python)
 
 Compound statements such as `begin`, `if`, `while` and `for` are supported.
+Import statements are supported, e.g.
+- `import foo, bar`
+- `from os.path import join as py_joinpath, exists`
 
 See the online documentation for more details.
 
@@ -895,6 +898,19 @@ See the online documentation for more details.
 macro py(ex)
     esc(py_macro(ex, __module__, __source__))
 end
+
+macro py(keyword, modulename, ex)
+    keyword == :from || return :( nothing )
+
+    d = Dict(isa(a.args[1], Symbol) ? a.args[1] => a.args[1] : a.args[1].args[1] => a.args[2]  for a in ex.args)
+    vars = Expr(:tuple, values(d)...)
+    imports = Tuple(keys(d))
+
+    esc(quote
+        $vars = pyimport($(string(modulename)) => $(string.(imports)))
+    end)
+end
+
 export @py
 
 end