unify error message by catching errors in cat_core; more test parametrization

Author: h-vetinari

pandas/core/strings.py

@@ -2290,9 +2290,10 @@ def _legal_dtype(series):
                      else series.cat.categories.dtype)
             legal = dtype == 'O' or (dtype == 'float' and series.isna().all())
             return legal
+        err_wrong_dtype = ('Can only concatenate list-likes containing only '
+                           'strings (or missing values)')
         if any(not _legal_dtype(x) for x in others):
-            raise TypeError('Can only concatenate list-likes containing only '
-                            'strings (or missing values)')
+            raise TypeError(err_wrong_dtype)
 
         if join is None and warn:
             warnings.warn("A future version of pandas will perform index "
@@ -2321,23 +2322,31 @@ def _legal_dtype(series):
         na_masks = np.array([isna(x) for x in all_cols])
         union_mask = np.logical_or.reduce(na_masks, axis=0)
 
-        if na_rep is None and union_mask.any():
-            # no na_rep means NaNs for all rows where any column has a NaN
-            # only necessary if there are actually any NaNs
-            result = np.empty(len(data), dtype=object)
-            np.putmask(result, union_mask, np.nan)
-
-            not_masked = ~union_mask
-            result[not_masked] = cat_core([x[not_masked] for x in all_cols],
-                                          sep)
-        elif na_rep is not None and union_mask.any():
-            # fill NaNs with na_rep in case there are actually any NaNs
-            all_cols = [np.where(nm, na_rep, col)
-                        for nm, col in zip(na_masks, all_cols)]
-            result = cat_core(all_cols, sep)
-        else:
-            # no NaNs - can just concatenate
-            result = cat_core(all_cols, sep)
+        # if there are any non-string, non-null values hidden within an object
+        # dtype, cat_core will fail; catch error and return better error.
+        try:
+            if na_rep is None and union_mask.any():
+                # no na_rep means NaNs for all rows where any column has a NaN
+                # only necessary if there are actually any NaNs
+                result = np.empty(len(data), dtype=object)
+                np.putmask(result, union_mask, np.nan)
+
+                not_masked = ~union_mask
+                result[not_masked] = cat_core([x[not_masked]
+                                               for x in all_cols], sep)
+            elif na_rep is not None and union_mask.any():
+                # fill NaNs with na_rep in case there are actually any NaNs
+                all_cols = [np.where(nm, na_rep, col)
+                            for nm, col in zip(na_masks, all_cols)]
+                result = cat_core(all_cols, sep)
+            else:
+                # no NaNs - can just concatenate
+                result = cat_core(all_cols, sep)
+        except TypeError as exc:
+            if re.match(r'can only concatenate str \(not \"\w+\"\) to str',
+                        str(exc)):
+                raise TypeError(err_wrong_dtype)
+            raise exc
 
         if isinstance(self._orig, Index):
             # add dtype for case that result is all-NA

pandas/tests/test_strings.py

@@ -420,15 +420,21 @@ def test_str_cat_categorical(self, box, dtype_caller, dtype_target, sep):
             result = s.str.cat(t, sep=sep)
             assert_series_or_index_equal(result, expected)
 
-    @pytest.mark.parametrize('box', [Series, Index, np.array, list])
-    def test_str_cat_wrong_dtype_raises(self, box):
+    # test integer/float dtypes (inferred by constructor) and mixed
+    @pytest.mark.parametrize('data', [[1, 2, 3], [.1, .2, .3], [1, 2, 'b']],
+                             ids=['integers', 'floats', 'mixed'])
+    # without dtype=object, np.array would cast [1, 2, 'b'] to ['1', '2', 'b']
+    @pytest.mark.parametrize('box', [Series, Index, list,
+                                     lambda x: np.array(x, dtype=object)],
+                             ids=['Series', 'Index', 'list', 'np.array'])
+    def test_str_cat_wrong_dtype_raises(self, box, data):
         # GH 22722
-        s = Series(['a', 'b', 'c', 'd'])
-        t = box([1, 2, 3, 4])
+        s = Series(['a', 'b', 'c'])
+        t = box(data)
 
         msg = 'Can only concatenate list-likes containing only strings.*'
         with pytest.raises(TypeError, match=msg):
-            s.str.cat(t)
+            s.str.cat(t, join='left')
 
     @pytest.mark.parametrize('box', [Series, Index])
     def test_str_cat_mixed_inputs(self, box):