CLN refactor core dtypes

pandas/core/dtypes/cast.py

@@ -2,6 +2,8 @@
 Routines for casting.
 """
 
+from __future__ import annotations
+
 from contextlib import suppress
 from datetime import date, datetime, timedelta
 from typing import (
@@ -126,12 +128,11 @@ def is_nested_object(obj) -> bool:
     This may not be necessarily be performant.
 
     """
-    if isinstance(obj, ABCSeries) and is_object_dtype(obj.dtype):
-
-        if any(isinstance(v, ABCSeries) for v in obj._values):
-            return True
-
-    return False
+    return bool(
+        isinstance(obj, ABCSeries)
+        and is_object_dtype(obj.dtype)
+        and any(isinstance(v, ABCSeries) for v in obj._values)
+    )
 
 
 def maybe_downcast_to_dtype(result, dtype: Union[str, np.dtype]):
@@ -272,7 +273,7 @@ def trans(x):
     return result
 
 
-def maybe_cast_result(result, obj: "Series", numeric_only: bool = False, how: str = ""):
+def maybe_cast_result(result, obj: Series, numeric_only: bool = False, how: str = ""):
     """
     Try casting result to a different type if appropriate
 
@@ -335,10 +336,11 @@ def maybe_cast_result_dtype(dtype: DtypeObj, how: str) -> DtypeObj:
     from pandas.core.arrays.boolean import BooleanDtype
     from pandas.core.arrays.integer import Int64Dtype
 
-    if how in ["add", "cumsum", "sum"] and (dtype == np.dtype(bool)):
-        return np.dtype(np.int64)
-    elif how in ["add", "cumsum", "sum"] and isinstance(dtype, BooleanDtype):
-        return Int64Dtype()
+    if how in ["add", "cumsum", "sum"]:
+        if dtype == np.dtype(bool):
+            return np.dtype(np.int64)
+        elif isinstance(dtype, BooleanDtype):
+            return Int64Dtype()
     return dtype
 
 
@@ -481,9 +483,11 @@ def maybe_casted_values(
     """
 
     values = index._values
-    if not isinstance(index, (ABCPeriodIndex, ABCDatetimeIndex)):
-        if values.dtype == np.object_:
-            values = lib.maybe_convert_objects(values)
+    if (
+        not isinstance(index, (ABCPeriodIndex, ABCDatetimeIndex))
+        and values.dtype == np.object_
+    ):
+        values = lib.maybe_convert_objects(values)
 
     # if we have the codes, extract the values with a mask
     if codes is not None:
@@ -725,8 +729,8 @@ def infer_dtype_from_scalar(val, pandas_dtype: bool = False) -> Tuple[DtypeObj,
 
     # a 1-element ndarray
     if isinstance(val, np.ndarray):
-        msg = "invalid ndarray passed to infer_dtype_from_scalar"
         if val.ndim != 0:
+            msg = "invalid ndarray passed to infer_dtype_from_scalar"
             raise ValueError(msg)
 
         dtype = val.dtype
@@ -1535,7 +1539,7 @@ def maybe_cast_to_datetime(value, dtype: DtypeObj, errors: str = "raise"):
     return value
 
 
-def find_common_type(types: List[DtypeObj]) -> DtypeObj:
+def find_common_type(types: Union[List[DtypeObj], Series]) -> DtypeObj:
     """
     Find a common data type among the given dtypes.
 
@@ -1841,12 +1845,16 @@ def validate_numeric_casting(dtype: np.dtype, value: Scalar) -> None:
     ------
     ValueError
     """
-    if issubclass(dtype.type, (np.integer, np.bool_)):
-        if is_float(value) and np.isnan(value):
-            raise ValueError("Cannot assign nan to integer series")
+    if (
+        issubclass(dtype.type, (np.integer, np.bool_))
+        and is_float(value)
+        and np.isnan(value)
+    ):
+        raise ValueError("Cannot assign nan to integer series")
 
-    if issubclass(dtype.type, (np.integer, np.floating, complex)) and not issubclass(
-        dtype.type, np.bool_
+    if (
+        issubclass(dtype.type, (np.integer, np.floating, complex))
+        and not issubclass(dtype.type, np.bool_)
+        and is_bool(value)
     ):
-        if is_bool(value):
-            raise ValueError("Cannot assign bool to float/integer series")
+        raise ValueError("Cannot assign bool to float/integer series")

pandas/core/dtypes/common.py

@@ -1698,7 +1698,7 @@ def infer_dtype_from_object(dtype):
         elif dtype in ["period"]:
             raise NotImplementedError
 
-        if dtype == "datetime" or dtype == "timedelta":
+        if dtype in ["datetime", "timedelta"]:
             dtype += "64"
         try:
             return infer_dtype_from_object(getattr(np, dtype))
@@ -1733,7 +1733,7 @@ def _validate_date_like_dtype(dtype) -> None:
         typ = np.datetime_data(dtype)[0]
     except ValueError as e:
         raise TypeError(e) from e
-    if typ != "generic" and typ != "ns":
+    if typ not in ["generic", "ns"]:
         raise ValueError(
             f"{repr(dtype.name)} is too specific of a frequency, "
             f"try passing {repr(dtype.type.__name__)}"

pandas/core/dtypes/concat.py

@@ -91,10 +91,9 @@ def _cast_to_common_type(arr: ArrayLike, dtype: DtypeObj) -> ArrayLike:
         # are not coming from Index/Series._values), eg in BlockManager.quantile
         arr = array(arr)
 
-    if is_extension_array_dtype(dtype):
-        if isinstance(arr, np.ndarray):
-            # numpy's astype cannot handle ExtensionDtypes
-            return array(arr, dtype=dtype, copy=False)
+    if is_extension_array_dtype(dtype) and isinstance(arr, np.ndarray):
+        # numpy's astype cannot handle ExtensionDtypes
+        return array(arr, dtype=dtype, copy=False)
     return arr.astype(dtype, copy=False)
 
 

pandas/core/dtypes/dtypes.py

@@ -419,14 +419,13 @@ def _hash_categories(categories, ordered: Ordered = True) -> int:
             categories = list(categories)  # breaks if a np.array of categories
             cat_array = hash_tuples(categories)
         else:
-            if categories.dtype == "O":
-                if len({type(x) for x in categories}) != 1:
-                    # TODO: hash_array doesn't handle mixed types. It casts
-                    # everything to a str first, which means we treat
-                    # {'1', '2'} the same as {'1', 2}
-                    # find a better solution
-                    hashed = hash((tuple(categories), ordered))
-                    return hashed
+            if categories.dtype == "O" and len({type(x) for x in categories}) != 1:
+                # TODO: hash_array doesn't handle mixed types. It casts
+                # everything to a str first, which means we treat
+                # {'1', '2'} the same as {'1', 2}
+                # find a better solution
+                hashed = hash((tuple(categories), ordered))
+                return hashed
 
             if DatetimeTZDtype.is_dtype(categories.dtype):
                 # Avoid future warning.
@@ -903,7 +902,7 @@ def __hash__(self) -> int:
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, str):
-            return other == self.name or other == self.name.title()
+            return other in [self.name, self.name.title()]
 
         return isinstance(other, PeriodDtype) and self.freq == other.freq
 

pandas/core/dtypes/inference.py

@@ -125,10 +125,7 @@ def is_file_like(obj) -> bool:
     if not (hasattr(obj, "read") or hasattr(obj, "write")):
         return False
 
-    if not hasattr(obj, "__iter__"):
-        return False
-
-    return True
+    return bool(hasattr(obj, "__iter__"))
 
 
 def is_re(obj) -> bool:

pandas/core/dtypes/missing.py

@@ -358,8 +358,8 @@ def isna_compat(arr, fill_value=np.nan) -> bool:
     -------
     True if we can fill using this fill_value
     """
-    dtype = arr.dtype
     if isna(fill_value):
+        dtype = arr.dtype
         return not (is_bool_dtype(dtype) or is_integer_dtype(dtype))
     return True
 
@@ -447,9 +447,10 @@ def array_equivalent(
         right = right.view("i8")
 
     # if we have structured dtypes, compare first
-    if left.dtype.type is np.void or right.dtype.type is np.void:
-        if left.dtype != right.dtype:
-            return False
+    if (
+        left.dtype.type is np.void or right.dtype.type is np.void
+    ) and left.dtype != right.dtype:
+        return False
 
     return np.array_equal(left, right)
 
@@ -484,11 +485,11 @@ def _array_equivalent_object(left, right, strict_nan):
                 if np.any(np.asarray(left_value != right_value)):
                     return False
             except TypeError as err:
-                if "Cannot compare tz-naive" in str(err):
+                if "Cannot compare tz-naive" in str(
+                    err
+                ) or "boolean value of NA is ambiguous" in str(err):
                     # tzawareness compat failure, see GH#28507
                     return False
-                elif "boolean value of NA is ambiguous" in str(err):
-                    return False
                 raise
     return True
 
@@ -637,8 +638,6 @@ def isna_all(arr: ArrayLike) -> bool:
     else:
         checker = lambda x: _isna_ndarraylike(x, inf_as_na=INF_AS_NA)
 
-    for i in range(0, total_len, chunk_len):
-        if not checker(arr[i : i + chunk_len]).all():
-            return False
-
-    return True
+    return all(
+        checker(arr[i : i + chunk_len]).all() for i in range(0, total_len, chunk_len)
+    )