From 0e95f2251f3f4f5115ca724d4c3a5f60fe2149c8 Mon Sep 17 00:00:00 2001
From: Vincent Gao <gaobing1230@gmail.com>
Date: Mon, 1 Jun 2026 14:34:38 +0200
Subject: [PATCH] Allow concatenation of string coordinates of differing width

Concatenation compared coordinate dtypes exactly, so two cubes whose
string coordinate differed only in width (e.g. '<U1' vs '<U5') were
reported as having differing metadata and could not be concatenated.
When comparing the coordinate signatures, collapse string dtypes to
their kind so differing widths no longer block concatenation; numpy
promotes the points to a common width when they are joined. Genuine
dtype-kind differences (e.g. string vs integer) are still rejected.

Fixes #6676.
---
 docs/src/whatsnew/latest.rst                  |  5 +++
 lib/iris/_concatenate.py                      | 17 +++++++++
 .../unit/concatenate/test_concatenate.py      | 35 +++++++++++++++++++
 3 files changed, 57 insertions(+)

diff --git a/docs/src/whatsnew/latest.rst b/docs/src/whatsnew/latest.rst
index 12720cecae..c0aefae2e1 100644
--- a/docs/src/whatsnew/latest.rst
+++ b/docs/src/whatsnew/latest.rst
@@ -56,6 +56,11 @@ This document explains the changes made to Iris for this release
    always promoting the result to ``float64``. Integer inputs are still returned
    as ``float64``. (:issue:`4119`)
 
+#. :user:`gaoflow` fixed :func:`iris.cube.CubeList.concatenate` so that cubes
+   with string coordinates of differing width (e.g. dtypes ``<U1`` and ``<U5``)
+   can be concatenated, with the result promoted to the wider dtype.
+   (:issue:`6676`)
+
 
 💣 Incompatible Changes
 =======================
diff --git a/lib/iris/_concatenate.py b/lib/iris/_concatenate.py
index f03125b37f..db38af486b 100644
--- a/lib/iris/_concatenate.py
+++ b/lib/iris/_concatenate.py
@@ -42,6 +42,19 @@
 _INCREASING = 1
 
 
+def _dtype_for_concat_compare(dtype):
+    """Normalise a dtype for comparing coordinates that are about to be concatenated.
+
+    String coordinates of the same kind but differing width (e.g. ``"<U1"`` and
+    ``"<U5"``) should not prevent concatenation: numpy promotes them to a common
+    width when the points are joined. Collapse such dtypes to their kind so that
+    they compare equal, while leaving every other dtype unchanged. See #6676.
+    """
+    if dtype is not None and dtype.kind in ("U", "S"):
+        return dtype.kind
+    return dtype
+
+
 class _CoordAndDims(namedtuple("CoordAndDims", ["coord", "dims"])):
     """Container for a coordinate and the associated data dimension(s).
 
@@ -131,6 +144,10 @@ def __eq__(self, other):
             sprops, oprops = self._asdict(), other._asdict()
             # Ignore "kwargs" meta-data for the first comparison.
             sprops["kwargs"] = oprops["kwargs"] = None
+            # String coordinates of differing width must not block concatenation.
+            for props in (sprops, oprops):
+                props["points_dtype"] = _dtype_for_concat_compare(props["points_dtype"])
+                props["bounds_dtype"] = _dtype_for_concat_compare(props["bounds_dtype"])
             result = sprops == oprops
             if result:
                 skwargs, okwargs = self.kwargs.copy(), other.kwargs.copy()
diff --git a/lib/iris/tests/unit/concatenate/test_concatenate.py b/lib/iris/tests/unit/concatenate/test_concatenate.py
index c08aba238a..b1f4bbe535 100644
--- a/lib/iris/tests/unit/concatenate/test_concatenate.py
+++ b/lib/iris/tests/unit/concatenate/test_concatenate.py
@@ -389,6 +389,41 @@ def test_desc_bounds_all_singleton(self):
         assert result1 == result2
 
 
+class TestStringAuxCoordWidths:
+    # Cubes with string auxiliary coordinates of differing width (dtype) should
+    # still concatenate, with the result promoted to the wider dtype (#6676).
+    def _make_cube(self, dim_points, string_points):
+        data = np.arange(len(dim_points))
+        cube = iris.cube.Cube(data, long_name="test")
+        cube.add_dim_coord(iris.coords.DimCoord(dim_points, long_name="dim"), 0)
+        cube.add_aux_coord(
+            iris.coords.AuxCoord(np.array(string_points), long_name="example"), 0
+        )
+        return cube
+
+    def test_different_widths(self):
+        cube_a = self._make_cube([0, 1], ["1", "2"])
+        cube_b = self._make_cube([10, 11, 12], ["1", "123", "12345"])
+        assert cube_a.coord("example").dtype != cube_b.coord("example").dtype
+
+        (result,) = concatenate([cube_a, cube_b])
+
+        coord = result.coord("example")
+        assert coord.dtype == np.dtype("<U5")
+        np.testing.assert_array_equal(coord.points, ["1", "2", "1", "123", "12345"])
+
+    def test_different_dtype_kind_still_rejected(self):
+        # A genuine dtype-kind difference (string vs integer) must still block
+        # concatenation.
+        cube_a = self._make_cube([0, 1], ["1", "2"])
+        cube_b = iris.cube.Cube(np.array([2, 3]), long_name="test")
+        cube_b.add_dim_coord(iris.coords.DimCoord([2, 3], long_name="dim"), 0)
+        cube_b.add_aux_coord(iris.coords.AuxCoord([1, 2], long_name="example"), 0)
+
+        with pytest.raises(ConcatenateError):
+            _ = concatenate([cube_a, cube_b], True)
+
+
 class TestConcatenate__dask:
     @pytest.fixture
     def sample_lazy_cubes(self):