fix: Respect strictness in list constructor

crates/polars-core/src/series/any_value.rs

@@ -563,8 +563,14 @@ fn any_values_to_list(
                         Some(b.clone())
                     } else {
                         match b.cast(inner_type) {
-                            Ok(out) => Some(out),
+                            Ok(out) => {
+                                if out.null_count() != b.null_count() {
+                                    valid = !strict;
+                                }
+                                Some(out)
+                            },
                             Err(_) => {
+                                valid = !strict;
                                 Some(Series::full_null(b.name().clone(), b.len(), inner_type))
                             },
                         }

crates/polars-python/src/series/construction.rs

@@ -168,15 +168,19 @@ init_method_opt!(new_opt_i64, Int64Type, i64);
 init_method_opt!(new_opt_f32, Float32Type, f32);
 init_method_opt!(new_opt_f64, Float64Type, f64);
 
+fn convert_to_avs<'a>(values: &'a Bound<'a, PyAny>, strict: bool) -> PyResult<Vec<AnyValue<'a>>> {
+    values
+        .iter()?
+        .map(|v| py_object_to_any_value(&(v?).as_borrowed(), strict))
+        .collect()
+}
+
 #[pymethods]
 impl PySeries {
     #[staticmethod]
     fn new_from_any_values(name: &str, values: &Bound<PyAny>, strict: bool) -> PyResult<Self> {
-        let any_values_result = values
-            .iter()?
-            .map(|v| py_object_to_any_value(&(v?).as_borrowed(), strict))
-            .collect::<PyResult<Vec<AnyValue>>>();
-        let result = any_values_result.and_then(|avs| {
+        let avs = convert_to_avs(values, strict);
+        let result = avs.and_then(|avs| {
             let s = Series::from_any_values(name.into(), avs.as_slice(), strict).map_err(|e| {
                 PyTypeError::new_err(format!(
                     "{e}\n\nHint: Try setting `strict=False` to allow passing data with mixed types."
@@ -211,17 +215,13 @@ impl PySeries {
         dtype: Wrap<DataType>,
         strict: bool,
     ) -> PyResult<Self> {
-        let any_values = values
-            .iter()?
-            .map(|v| py_object_to_any_value(&(v?).as_borrowed(), strict))
-            .collect::<PyResult<Vec<AnyValue>>>()?;
-        let s =
-            Series::from_any_values_and_dtype(name.into(), any_values.as_slice(), &dtype.0, strict)
-                .map_err(|e| {
-                    PyTypeError::new_err(format!(
+        let avs = convert_to_avs(values, strict)?;
+        let s = Series::from_any_values_and_dtype(name.into(), avs.as_slice(), &dtype.0, strict)
+            .map_err(|e| {
+                PyTypeError::new_err(format!(
                 "{e}\n\nHint: Try setting `strict=False` to allow passing data with mixed types."
             ))
-                })?;
+            })?;
         Ok(s.into())
     }
 

py-polars/tests/unit/constructors/test_strictness.py

@@ -0,0 +1,8 @@
+import pytest
+
+import polars as pl
+
+
+def test_list_constructor_strictness() -> None:
+    with pytest.raises(TypeError, match="setting `strict=False`"):
+        pl.Series([[1], ["two"]], strict=True)