feat(rust): utf8 to temporal casting

crates/polars-arrow/src/compute/cast/mod.rs

@@ -580,9 +580,9 @@ pub fn cast(
             LargeUtf8 => Ok(Box::new(utf8_to_large_utf8(
                 array.as_any().downcast_ref().unwrap(),
             ))),
-            Timestamp(TimeUnit::Nanosecond, None) => utf8_to_naive_timestamp_ns_dyn::<i32>(array),
-            Timestamp(TimeUnit::Nanosecond, Some(tz)) => {
-                utf8_to_timestamp_ns_dyn::<i32>(array, tz.clone())
+            Timestamp(tu, None) => utf8_to_naive_timestamp_dyn::<i32>(array, tu.to_owned()),
+            Timestamp(tu, Some(tz)) => {
+                utf8_to_timestamp_dyn::<i32>(array, tz.clone(), tu.to_owned())
             },
             _ => polars_bail!(InvalidOperation:
                 "casting from {from_type:?} to {to_type:?} not supported",
@@ -607,9 +607,9 @@ pub fn cast(
                 to_type.clone(),
             )
             .boxed()),
-            Timestamp(TimeUnit::Nanosecond, None) => utf8_to_naive_timestamp_ns_dyn::<i64>(array),
-            Timestamp(TimeUnit::Nanosecond, Some(tz)) => {
-                utf8_to_timestamp_ns_dyn::<i64>(array, tz.clone())
+            Timestamp(tu, None) => utf8_to_naive_timestamp_dyn::<i64>(array, tu.to_owned()),
+            Timestamp(tu, Some(tz)) => {
+                utf8_to_timestamp_dyn::<i64>(array, tz.clone(), tu.to_owned())
             },
             _ => polars_bail!(InvalidOperation:
                 "casting from {from_type:?} to {to_type:?} not supported",

crates/polars-arrow/src/compute/cast/utf8_to.rs

@@ -3,11 +3,11 @@ use polars_error::PolarsResult;
 
 use super::CastOptions;
 use crate::array::*;
-use crate::datatypes::DataType;
+use crate::datatypes::{DataType, TimeUnit};
 use crate::offset::Offset;
 use crate::temporal_conversions::{
-    utf8_to_naive_timestamp_ns as utf8_to_naive_timestamp_ns_,
-    utf8_to_timestamp_ns as utf8_to_timestamp_ns_, EPOCH_DAYS_FROM_CE,
+    utf8_to_naive_timestamp as utf8_to_naive_timestamp_, utf8_to_timestamp as utf8_to_timestamp_,
+    EPOCH_DAYS_FROM_CE,
 };
 use crate::types::NativeType;
 
@@ -110,34 +110,40 @@ pub fn utf8_to_dictionary<O: Offset, K: DictionaryKey>(
     Ok(array.into())
 }
 
-pub(super) fn utf8_to_naive_timestamp_ns_dyn<O: Offset>(
+pub(super) fn utf8_to_naive_timestamp_dyn<O: Offset>(
     from: &dyn Array,
+    tu: TimeUnit,
 ) -> PolarsResult<Box<dyn Array>> {
     let from = from.as_any().downcast_ref().unwrap();
-    Ok(Box::new(utf8_to_naive_timestamp_ns::<O>(from)))
+    Ok(Box::new(utf8_to_naive_timestamp::<O>(from, tu)))
 }
 
-/// [`crate::temporal_conversions::utf8_to_timestamp_ns`] applied for RFC3339 formatting
-pub fn utf8_to_naive_timestamp_ns<O: Offset>(from: &Utf8Array<O>) -> PrimitiveArray<i64> {
-    utf8_to_naive_timestamp_ns_(from, RFC3339)
+/// [`crate::temporal_conversions::utf8_to_timestamp`] applied for RFC3339 formatting
+pub fn utf8_to_naive_timestamp<O: Offset>(
+    from: &Utf8Array<O>,
+    tu: TimeUnit,
+) -> PrimitiveArray<i64> {
+    utf8_to_naive_timestamp_(from, RFC3339, tu)
 }
 
-pub(super) fn utf8_to_timestamp_ns_dyn<O: Offset>(
+pub(super) fn utf8_to_timestamp_dyn<O: Offset>(
     from: &dyn Array,
     timezone: String,
+    tu: TimeUnit,
 ) -> PolarsResult<Box<dyn Array>> {
     let from = from.as_any().downcast_ref().unwrap();
-    utf8_to_timestamp_ns::<O>(from, timezone)
+    utf8_to_timestamp::<O>(from, timezone, tu)
         .map(Box::new)
         .map(|x| x as Box<dyn Array>)
 }
 
-/// [`crate::temporal_conversions::utf8_to_timestamp_ns`] applied for RFC3339 formatting
-pub fn utf8_to_timestamp_ns<O: Offset>(
+/// [`crate::temporal_conversions::utf8_to_timestamp`] applied for RFC3339 formatting
+pub fn utf8_to_timestamp<O: Offset>(
     from: &Utf8Array<O>,
     timezone: String,
+    tu: TimeUnit,
 ) -> PolarsResult<PrimitiveArray<i64>> {
-    utf8_to_timestamp_ns_(from, RFC3339, timezone)
+    utf8_to_timestamp_(from, RFC3339, timezone, tu)
 }
 
 /// Conversion of utf8

crates/polars-arrow/src/temporal_conversions.rs

@@ -321,17 +321,6 @@ pub fn parse_offset(offset: &str) -> PolarsResult<FixedOffset> {
         .expect("FixedOffset::east out of bounds"))
 }
 
-/// Parses `value` to `Option<i64>` consistent with the Arrow's definition of timestamp with timezone.
-/// `tz` must be built from `timezone` (either via [`parse_offset`] or `chrono-tz`).
-#[inline]
-pub fn utf8_to_timestamp_ns_scalar<T: chrono::TimeZone>(
-    value: &str,
-    fmt: &str,
-    tz: &T,
-) -> Option<i64> {
-    utf8_to_timestamp_scalar(value, fmt, tz, &TimeUnit::Nanosecond)
-}
-
 /// Parses `value` to `Option<i64>` consistent with the Arrow's definition of timestamp with timezone.
 /// `tz` must be built from `timezone` (either via [`parse_offset`] or `chrono-tz`).
 /// Returns in scale `tz` of `TimeUnit`.
@@ -362,12 +351,6 @@ pub fn utf8_to_timestamp_scalar<T: chrono::TimeZone>(
     }
 }
 
-/// Parses `value` to `Option<i64>` consistent with the Arrow's definition of timestamp without timezone.
-#[inline]
-pub fn utf8_to_naive_timestamp_ns_scalar(value: &str, fmt: &str) -> Option<i64> {
-    utf8_to_naive_timestamp_scalar(value, fmt, &TimeUnit::Nanosecond)
-}
-
 /// Parses `value` to `Option<i64>` consistent with the Arrow's definition of timestamp without timezone.
 /// Returns in scale `tz` of `TimeUnit`.
 #[inline]
@@ -386,18 +369,18 @@ pub fn utf8_to_naive_timestamp_scalar(value: &str, fmt: &str, tu: &TimeUnit) ->
         .ok()
 }
 
-fn utf8_to_timestamp_ns_impl<O: Offset, T: chrono::TimeZone>(
+fn utf8_to_timestamp_impl<O: Offset, T: chrono::TimeZone>(
     array: &Utf8Array<O>,
     fmt: &str,
     timezone: String,
     tz: T,
+    tu: TimeUnit,
 ) -> PrimitiveArray<i64> {
     let iter = array
         .iter()
-        .map(|x| x.and_then(|x| utf8_to_timestamp_ns_scalar(x, fmt, &tz)));
+        .map(|x| x.and_then(|x| utf8_to_timestamp_scalar(x, fmt, &tz, &tu)));
 
-    PrimitiveArray::from_trusted_len_iter(iter)
-        .to(DataType::Timestamp(TimeUnit::Nanosecond, Some(timezone)))
+    PrimitiveArray::from_trusted_len_iter(iter).to(DataType::Timestamp(tu, Some(timezone)))
 }
 
 /// Parses `value` to a [`chrono_tz::Tz`] with the Arrow's definition of timestamp with a timezone.
@@ -411,59 +394,63 @@ pub fn parse_offset_tz(timezone: &str) -> PolarsResult<chrono_tz::Tz> {
 
 #[cfg(feature = "chrono-tz")]
 #[cfg_attr(docsrs, doc(cfg(feature = "chrono-tz")))]
-fn chrono_tz_utf_to_timestamp_ns<O: Offset>(
+fn chrono_tz_utf_to_timestamp<O: Offset>(
     array: &Utf8Array<O>,
     fmt: &str,
     timezone: String,
+    tu: TimeUnit,
 ) -> PolarsResult<PrimitiveArray<i64>> {
     let tz = parse_offset_tz(&timezone)?;
-    Ok(utf8_to_timestamp_ns_impl(array, fmt, timezone, tz))
+    Ok(utf8_to_timestamp_impl(array, fmt, timezone, tz, tu))
 }
 
 #[cfg(not(feature = "chrono-tz"))]
-fn chrono_tz_utf_to_timestamp_ns<O: Offset>(
+fn chrono_tz_utf_to_timestamp<O: Offset>(
     _: &Utf8Array<O>,
     _: &str,
     timezone: String,
+    _: TimeUnit,
 ) -> PolarsResult<PrimitiveArray<i64>> {
     panic!("timezone \"{timezone}\" cannot be parsed (feature chrono-tz is not active)")
 }
 
 /// Parses a [`Utf8Array`] to a timeozone-aware timestamp, i.e. [`PrimitiveArray<i64>`] with type `Timestamp(Nanosecond, Some(timezone))`.
 /// # Implementation
 /// * parsed values with timezone other than `timezone` are converted to `timezone`.
-/// * parsed values without timezone are null. Use [`utf8_to_naive_timestamp_ns`] to parse naive timezones.
+/// * parsed values without timezone are null. Use [`utf8_to_naive_timestamp`] to parse naive timezones.
 /// * Null elements remain null; non-parsable elements are null.
 /// The feature `"chrono-tz"` enables IANA and zoneinfo formats for `timezone`.
 /// # Error
 /// This function errors iff `timezone` is not parsable to an offset.
-pub fn utf8_to_timestamp_ns<O: Offset>(
+pub fn utf8_to_timestamp<O: Offset>(
     array: &Utf8Array<O>,
     fmt: &str,
     timezone: String,
+    tu: TimeUnit,
 ) -> PolarsResult<PrimitiveArray<i64>> {
     let tz = parse_offset(timezone.as_str());
 
     if let Ok(tz) = tz {
-        Ok(utf8_to_timestamp_ns_impl(array, fmt, timezone, tz))
+        Ok(utf8_to_timestamp_impl(array, fmt, timezone, tz, tu))
     } else {
-        chrono_tz_utf_to_timestamp_ns(array, fmt, timezone)
+        chrono_tz_utf_to_timestamp(array, fmt, timezone, tu)
     }
 }
 
 /// Parses a [`Utf8Array`] to naive timestamp, i.e.
 /// [`PrimitiveArray<i64>`] with type `Timestamp(Nanosecond, None)`.
 /// Timezones are ignored.
 /// Null elements remain null; non-parsable elements are set to null.
-pub fn utf8_to_naive_timestamp_ns<O: Offset>(
+pub fn utf8_to_naive_timestamp<O: Offset>(
     array: &Utf8Array<O>,
     fmt: &str,
+    tu: TimeUnit,
 ) -> PrimitiveArray<i64> {
     let iter = array
         .iter()
-        .map(|x| x.and_then(|x| utf8_to_naive_timestamp_ns_scalar(x, fmt)));
+        .map(|x| x.and_then(|x| utf8_to_naive_timestamp_scalar(x, fmt, &tu)));
 
-    PrimitiveArray::from_trusted_len_iter(iter).to(DataType::Timestamp(TimeUnit::Nanosecond, None))
+    PrimitiveArray::from_trusted_len_iter(iter).to(DataType::Timestamp(tu, None))
 }
 
 fn add_month(year: i32, month: u32, months: i32) -> chrono::NaiveDate {

crates/polars-core/src/chunked_array/cast.rs

@@ -7,6 +7,7 @@ use arrow::compute::cast::CastOptions;
 use crate::chunked_array::categorical::CategoricalChunkedBuilder;
 #[cfg(feature = "timezones")]
 use crate::chunked_array::temporal::validate_time_zone;
+use crate::prelude::DataType::Datetime;
 use crate::prelude::*;
 
 pub(crate) fn cast_chunks(
@@ -195,6 +196,33 @@ impl ChunkCast for Utf8Chunked {
                     polars_bail!(ComputeError: "expected 'precision' or 'scale' when casting to Decimal")
                 },
             },
+            #[cfg(feature = "dtype-date")]
+            DataType::Date => {
+                let result = cast_chunks(&self.chunks, data_type, true)?;
+                let out = Series::try_from((self.name(), result))?;
+                Ok(out)
+            },
+            #[cfg(feature = "dtype-datetime")]
+            DataType::Datetime(tu, tz) => {
+                let out = match tz {
+                    #[cfg(feature = "timezones")]
+                    Some(tz) => {
+                        validate_time_zone(tz)?;
+                        let result = cast_chunks(
+                            &self.chunks,
+                            &Datetime(tu.to_owned(), Some(tz.clone())),
+                            true,
+                        )?;
+                        Series::try_from((self.name(), result))
+                    },
+                    _ => {
+                        let result =
+                            cast_chunks(&self.chunks, &Datetime(tu.to_owned(), None), true)?;
+                        Series::try_from((self.name(), result))
+                    },
+                };
+                out
+            },
             _ => cast_impl(self.name(), &self.chunks, data_type),
         }
     }

py-polars/tests/unit/test_lazy.py

@@ -1375,7 +1375,7 @@ def test_quadratic_behavior_4736() -> None:
     ldf.select(reduce(add, (pl.col(fld) for fld in ldf.columns)))
 
 
-@pytest.mark.parametrize("input_dtype", [pl.Utf8, pl.Int64, pl.Float64])
+@pytest.mark.parametrize("input_dtype", [pl.Int64, pl.Float64])
 def test_from_epoch(input_dtype: pl.PolarsDataType) -> None:
     ldf = pl.LazyFrame(
         [
@@ -1415,6 +1415,23 @@ def test_from_epoch(input_dtype: pl.PolarsDataType) -> None:
         _ = ldf.select(pl.from_epoch(ts_col, time_unit="s2"))  # type: ignore[call-overload]
 
 
+def test_from_epoch_str() -> None:
+    ldf = pl.LazyFrame(
+        [
+            pl.Series("timestamp_ms", [1147880044 * 1_000]).cast(pl.Utf8),
+            pl.Series("timestamp_us", [1147880044 * 1_000_000]).cast(pl.Utf8),
+        ]
+    )
+
+    with pytest.raises(ComputeError):
+        ldf.select(
+            [
+                pl.from_epoch(pl.col("timestamp_ms"), time_unit="ms"),
+                pl.from_epoch(pl.col("timestamp_us"), time_unit="us"),
+            ]
+        ).collect()
+
+
 def test_cumagg_types() -> None:
     ldf = pl.LazyFrame({"a": [1, 2], "b": [True, False], "c": [1.3, 2.4]})
     cumsum_lf = ldf.select(