Allow writing StringDType variables to netCDF (pydata#11218)

* Allow writing StringDType variables to netCDF (pydata#11199)

Recognize numpy.dtypes.StringDType (kind "T") as a unicode string type
in is_unicode_dtype, and convert StringDType arrays to object arrays
before passing to netCDF4/h5netcdf backends which don't support
StringDType natively. Null values from StringDType(na_object=None) are
replaced with empty strings on write.

Co-authored-by: Claude <noreply@anthropic.com>

* Add StringDType null handling for scipy and tests for review feedback

- Handle StringDType null values in encode_string_array (scipy/nc3 path)
- Add roundtrip tests for StringDType with na_object=None and na_object=""
- Add unit test for encode_string_array with StringDType nulls

Co-Authored-By: Claude <noreply@anthropic.com>

* Move StringDType handling into shared encoder (pydata#11199)

Convert StringDType to fixed-width unicode (U) in EncodedStringCoder.encode()
instead of per-backend prepare_variable, fixing Zarr and CFEncodedDataStore.

Co-authored-by: Claude <noreply@anthropic.com>

---------

Co-authored-by: Claude <noreply@anthropic.com>
Co-authored-by: Julia Signell <jsignell@gmail.com>

Author: 3 people

doc/whats-new.rst

@@ -43,6 +43,8 @@ Deprecations
 Bug Fixes
 ~~~~~~~~~
 
+- Allow writing ``StringDType`` variables to netCDF files (:issue:`11199`).
+  By `Kristian Kollsgård <https://github.com/kkollsga>`_.
 - Fix ``Source`` link in api docs (:pull:`11187`)
   By `Ian Hunt-Isaak <https://github.com/ianhi>`_
 - Coerce masked dask arrays to filled (:issue:`9374` :pull:`11157`).

xarray/coding/strings.py

@@ -40,7 +40,7 @@ def check_vlen_dtype(dtype):
 
 
 def is_unicode_dtype(dtype):
-    return dtype.kind == "U" or check_vlen_dtype(dtype) is str
+    return dtype.kind in ("U", "T") or check_vlen_dtype(dtype) is str
 
 
 def is_bytes_dtype(dtype):
@@ -56,6 +56,14 @@ def __init__(self, allows_unicode=True):
     def encode(self, variable: Variable, name=None) -> Variable:
         dims, data, attrs, encoding = unpack_for_encoding(variable)
 
+        # StringDType: replace nulls and convert to fixed-width unicode (U),
+        # which all backends support natively (GH11199)
+        if data.dtype.kind == "T":
+            data = np.asarray(data, dtype=object)
+            data[data == None] = ""  # noqa: E711
+            data = np.asarray(data, dtype="U")
+            variable = Variable(dims, data, attrs, encoding)
+
         contains_unicode = is_unicode_dtype(data.dtype)
         encode_as_char = encoding.get("dtype") == "S1"
         if encode_as_char:

xarray/tests/test_backends.py

@@ -701,6 +701,31 @@ def test_roundtrip_string_data(self) -> None:
         with self.roundtrip(expected) as actual:
             assert_identical(expected, actual)
 
+    @pytest.mark.skipif(not HAS_STRING_DTYPE, reason="requires StringDType")
+    def test_roundtrip_stringdtype_data(self) -> None:
+        # GH11199
+        data = np.array(["ab", "cdef"], dtype=np.dtypes.StringDType())
+        expected = Dataset({"x": ("t", data)})
+        with self.roundtrip(expected) as actual:
+            assert_identical(expected, actual)
+
+    @pytest.mark.skipif(not HAS_STRING_DTYPE, reason="requires StringDType")
+    def test_roundtrip_stringdtype_nulls(self) -> None:
+        # GH11199 — null values in StringDType are written as empty strings
+        data = np.array(["ab", None], dtype=np.dtypes.StringDType(na_object=None))
+        ds = Dataset({"x": ("t", data)})
+        with self.roundtrip(ds) as actual:
+            expected = Dataset({"x": ("t", np.array(["ab", ""]))})
+            assert_identical(expected, actual)
+
+    @pytest.mark.skipif(not HAS_STRING_DTYPE, reason="requires StringDType")
+    def test_roundtrip_stringdtype_with_na_object(self) -> None:
+        # GH11199 — StringDType(na_object="") should roundtrip correctly
+        data = np.array(["ab", "cdef"], dtype=np.dtypes.StringDType(na_object=""))
+        expected = Dataset({"x": ("t", data)})
+        with self.roundtrip(expected) as actual:
+            assert_identical(expected, actual)
+
     def test_roundtrip_string_encoded_characters(self) -> None:
         expected = Dataset({"x": ("t", ["ab", "cdef"])})
         expected["x"].encoding["dtype"] = "S1"

xarray/tests/test_coding_strings.py

@@ -39,6 +39,16 @@ def test_vlen_dtype() -> None:
     assert strings.check_vlen_dtype(np.dtype(object)) is None
 
 
+@pytest.mark.skipif(
+    not hasattr(np.dtypes, "StringDType"), reason="requires StringDType"
+)
+def test_is_unicode_dtype_stringdtype() -> None:
+    # GH11199
+    dtype = np.dtypes.StringDType()
+    assert strings.is_unicode_dtype(dtype)
+    assert not strings.is_bytes_dtype(dtype)
+
+
 @pytest.mark.parametrize("numpy_str_type", (np.str_, np.bytes_))
 def test_numpy_subclass_handling(numpy_str_type) -> None:
     with pytest.raises(TypeError, match="unsupported type for vlen_dtype"):
@@ -93,6 +103,20 @@ def test_EncodedStringCoder_encode() -> None:
     assert_identical(coder.encode(raw), expected)
 
 
+@pytest.mark.skipif(
+    not hasattr(np.dtypes, "StringDType"), reason="requires StringDType"
+)
+def test_encoded_string_coder_stringdtype_nulls() -> None:
+    # GH11199 — EncodedStringCoder normalizes StringDType nulls to empty strings
+    data = np.array(["ab", None], dtype=np.dtypes.StringDType(na_object=None))
+    var = Variable("x", data)
+    coder = strings.EncodedStringCoder(allows_unicode=True)
+    result = coder.encode(var)
+    expected = Variable("x", np.array(["ab", ""]))
+    assert_identical(result, expected)
+    assert result.dtype.kind == "U"
+
+
 @pytest.mark.parametrize(
     "original",
     [