add categories_dtype to dtype string

Author: topper-123

pandas/_libs/lib.pyx

@@ -1388,6 +1388,12 @@ cdef object _try_infer_map(object dtype):
         val = getattr(dtype, attr, None)
         if val in _TYPE_MAP:
             return _TYPE_MAP[val]
+
+    # CategoricalDtype may have name category[dtype], so not caught above
+    name = getattr(dtype, "name", None)
+    if name.startswith("category["):
+        return _TYPE_MAP["category"]
+
     return None
 
 

pandas/core/arrays/categorical.py

@@ -1999,7 +1999,7 @@ def _repr_categories_info(self) -> str:
 
     def _repr_footer(self) -> str:
         info = self._repr_categories_info()
-        return f"Length: {len(self)}\n{info}"
+        return f"Length: {len(self)}, dtype: {self.dtype}\n{info}"
 
     def _get_repr(
         self, length: bool = True, na_rep: str = "NaN", footer: bool = True

pandas/core/dtypes/common.py

@@ -502,9 +502,8 @@ def is_categorical_dtype(arr_or_dtype) -> bool:
         FutureWarning,
         stacklevel=find_stack_level(),
     )
-    if isinstance(arr_or_dtype, ExtensionDtype):
-        # GH#33400 fastpath for dtype object
-        return arr_or_dtype.name == "category"
+    if isinstance(arr_or_dtype, CategoricalDtype):
+        return True
 
     if arr_or_dtype is None:
         return False

pandas/core/dtypes/dtypes.py

@@ -202,7 +202,6 @@ class CategoricalDtype(PandasExtensionDtype, ExtensionDtype):
     """
 
     # TODO: Document public vs. private API
-    name = "category"
     type: type[CategoricalDtypeType] = CategoricalDtypeType
     kind: str_type = "O"
     str = "|O08"
@@ -315,12 +314,12 @@ def _from_values_or_dtype(
         if dtype is not None:
             # The dtype argument takes precedence over values.dtype (if any)
             if isinstance(dtype, str):
-                if dtype == "category":
+                if dtype.startswith("category"):
                     if ordered is None and cls.is_dtype(values):
                         # GH#49309 preserve orderedness
                         ordered = values.dtype.ordered
-
-                    dtype = CategoricalDtype(categories, ordered)
+                    cat_dtype = cls._get_categories_dtype_from_string(dtype)
+                    dtype = CategoricalDtype(categories, ordered, cat_dtype)
                 else:
                     raise ValueError(f"Unknown dtype {repr(dtype)}")
             elif categories is not None or ordered is not None:
@@ -371,20 +370,27 @@ def construct_from_string(cls, string: str_type) -> CategoricalDtype:
         # need ordered=None to ensure that operations specifying dtype="category" don't
         # override the ordered value for existing categoricals
 
-        if string == cls.name:
+        if string == "category":
             return cls(ordered=None)
 
         msg = f"Cannot construct a '{cls.__name__}' from '{string}'"
+        categories_dtype = cls._get_categories_dtype_from_string(string)
+        if categories_dtype is None:
+            raise TypeError(msg)
+        try:
+            return cls(categories_dtype=categories_dtype)
+        except (KeyError, TypeError, ValueError) as err:
+            # keyError is if "categories_dtype" key is not found
+            # TypeError if we pass a nonsense;
+            raise TypeError(msg) from err
+
+    @classmethod
+    def _get_categories_dtype_from_string(cls, string: str_type) -> str_type | None:
         match = cls._match.match(string)
-        if match:
-            d = match.groupdict()
-            try:
-                return cls(categories_dtype=d["categories_dtype"])
-            except (KeyError, TypeError, ValueError) as err:
-                # keyError is if "categories_dtype" key is not found
-                # TypeError if we pass a nonsense;
-                raise TypeError(msg) from err
-        raise TypeError(msg)
+        if match is None:
+            return None
+        d = match.groupdict()
+        return d.get("categories_dtype")
 
     @property
     def categories_dtype(self) -> Dtype:
@@ -435,7 +441,7 @@ def __eq__(self, other: Any) -> bool:
         6) Any other comparison returns False
         """
         if isinstance(other, str):
-            return other == self.name
+            return other == self.name or other == "category"
         elif other is self:
             return True
         elif not (hasattr(other, "ordered") and hasattr(other, "categories")):
@@ -497,6 +503,15 @@ def __repr__(self) -> str_type:
             f"categories_dtype={self.categories_dtype})"
         )
 
+    @property
+    def name(self) -> str_type:
+        if self.categories is not None:
+            return f"category[{self.categories.dtype}]"
+        elif self.categories_dtype is not None:
+            return f"category[{self.categories_dtype}]"
+        else:
+            return "category"
+
     @cache_readonly
     def _hash_categories(self) -> int:
         from pandas.core.util.hashing import (

pandas/tests/arrays/categorical/test_operators.py

@@ -169,7 +169,7 @@ def test_comparison_with_unknown_scalars(self):
         # for unequal comps, but not for equal/not equal
         cat = Categorical([1, 2, 3], ordered=True)
 
-        msg = "Invalid comparison between dtype=category and int"
+        msg = r"Invalid comparison between dtype=category\[int64\] and int"
         with pytest.raises(TypeError, match=msg):
             cat < 4
         with pytest.raises(TypeError, match=msg):
@@ -398,6 +398,6 @@ def test_numeric_like_ops_series_arith(self, op, str_rep):
     def test_numeric_like_ops_series_invalid(self):
         # invalid ufunc
         s = Series(Categorical([1, 2, 3, 4]))
-        msg = "Object with dtype category cannot perform the numpy op log"
+        msg = r"Object with dtype category\[int64\] cannot perform the numpy op log"
         with pytest.raises(TypeError, match=msg):
             np.log(s)