CLN: Clean uses of super, part II

Author: topper-123

ci/code_checks.sh

@@ -141,7 +141,11 @@ if [[ -z "$CHECK" || "$CHECK" == "patterns" ]]; then
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
     MSG='Check for python2 new-style classes' ; echo $MSG
-    invgrep -R --include="*.py" --include="*.pyx" -E "class\s\S*\(object\):" pandas scripts
+    invgrep -R --include="*.py" --include="*.pyx" -E "class\s\S*\(object\):" pandas
+    RET=$(($RET + $?)) ; echo $MSG "DONE"
+
+    MSG='Check for python2-style super usage' ; echo $MSG
+    invgrep -R --include="*.py" --include="*.pyx" -E "super\(\w*, (self|cls)\)" pandas
     RET=$(($RET + $?)) ; echo $MSG "DONE"
 
     MSG='Check for backticks incorrectly rendering because of missing spaces' ; echo $MSG

pandas/_libs/index.pyx

@@ -483,44 +483,43 @@ cdef class TimedeltaEngine(DatetimeEngine):
 cdef class PeriodEngine(Int64Engine):
 
     cdef _get_index_values(self):
-        return super(PeriodEngine, self).vgetter()
+        return super().vgetter()
 
     cpdef _call_map_locations(self, values):
-        super(PeriodEngine, self)._call_map_locations(values.view('i8'))
+        super()._call_map_locations(values.view('i8'))
 
     def _call_monotonic(self, values):
-        return super(PeriodEngine, self)._call_monotonic(values.view('i8'))
+        return super()._call_monotonic(values.view('i8'))
 
     def get_indexer(self, values):
         cdef ndarray[int64_t, ndim=1] ordinals
 
-        super(PeriodEngine, self)._ensure_mapping_populated()
+        super()._ensure_mapping_populated()
 
-        freq = super(PeriodEngine, self).vgetter().freq
+        freq = super().vgetter().freq
         ordinals = periodlib.extract_ordinals(values, freq)
 
         return self.mapping.lookup(ordinals)
 
     def get_pad_indexer(self, other, limit=None):
-        freq = super(PeriodEngine, self).vgetter().freq
+        freq = super().vgetter().freq
         ordinal = periodlib.extract_ordinals(other, freq)
 
         return algos.pad(self._get_index_values(),
                          np.asarray(ordinal), limit=limit)
 
     def get_backfill_indexer(self, other, limit=None):
-        freq = super(PeriodEngine, self).vgetter().freq
+        freq = super().vgetter().freq
         ordinal = periodlib.extract_ordinals(other, freq)
 
         return algos.backfill(self._get_index_values(),
                               np.asarray(ordinal), limit=limit)
 
     def get_indexer_non_unique(self, targets):
-        freq = super(PeriodEngine, self).vgetter().freq
+        freq = super().vgetter().freq
         ordinal = periodlib.extract_ordinals(targets, freq)
         ordinal_array = np.asarray(ordinal)
-
-        return super(PeriodEngine, self).get_indexer_non_unique(ordinal_array)
+        return super().get_indexer_non_unique(ordinal_array)
 
 
 cpdef convert_scalar(ndarray arr, object value):

pandas/_libs/tslibs/timestamps.pyx

@@ -983,7 +983,7 @@ default 'raise'
         return create_timestamp_from_ts(value, dts, _tzinfo, self.freq)
 
     def isoformat(self, sep='T'):
-        base = super(_Timestamp, self).isoformat(sep=sep)
+        base = super().isoformat(sep=sep)
         if self.nanosecond == 0:
             return base
 

pandas/core/arrays/categorical.py

@@ -2010,9 +2010,6 @@ def _get_repr(self, length=True, na_rep='NaN', footer=True):
         return str(result)
 
     def __unicode__(self):
-        """
-        Unicode representation.
-        """
         _maxlen = 10
         if len(self._codes) > _maxlen:
             result = self._tidy_repr(_maxlen)
@@ -2025,8 +2022,8 @@ def __unicode__(self):
         return result
 
     def __repr__(self):
-        # We want PandasObject.__repr__, which dispatches to __unicode__
-        return super(ExtensionArray, self).__repr__()
+        # We want to bypass ExtensionArray.__repr__.
+        return str(self)
 
     def _maybe_coerce_indexer(self, indexer):
         """

pandas/core/arrays/sparse.py

@@ -1769,7 +1769,7 @@ def _add_unary_ops(cls):
     def _add_comparison_ops(cls):
         cls.__and__ = cls._create_comparison_method(operator.and_)
         cls.__or__ = cls._create_comparison_method(operator.or_)
-        super(SparseArray, cls)._add_comparison_ops()
+        super()._add_comparison_ops()
 
     # ----------
     # Formatting

pandas/core/dtypes/dtypes.py

@@ -879,7 +879,7 @@ def is_dtype(cls, dtype):
                     return False
             else:
                 return False
-        return super(PeriodDtype, cls).is_dtype(dtype)
+        return super().is_dtype(dtype)
 
     @classmethod
     def construct_array_type(cls):
@@ -1047,4 +1047,4 @@ def is_dtype(cls, dtype):
                     return False
             else:
                 return False
-        return super(IntervalDtype, cls).is_dtype(dtype)
+        return super().is_dtype(dtype)

pandas/core/frame.py

@@ -6330,8 +6330,7 @@ def _aggregate(self, arg, axis=0, *args, **kwargs):
         if axis == 1:
             # NDFrame.aggregate returns a tuple, and we need to transpose
             # only result
-            result, how = (super(DataFrame, self.T)
-                           ._aggregate(arg, *args, **kwargs))
+            result, how = self.T._aggregate(arg, *args, axis=0, **kwargs)
             result = result.T if result is not None else result
             return result, how
         return super()._aggregate(arg, *args, **kwargs)
@@ -6342,7 +6341,7 @@ def _aggregate(self, arg, axis=0, *args, **kwargs):
     def transform(self, func, axis=0, *args, **kwargs):
         axis = self._get_axis_number(axis)
         if axis == 1:
-            return super(DataFrame, self.T).transform(func, *args, **kwargs).T
+            return self.T.transform(func, *args, axis=0, **kwargs).T
         return super().transform(func, *args, **kwargs)
 
     def apply(self, func, axis=0, broadcast=None, raw=False, reduce=None,

pandas/core/groupby/grouper.py

@@ -90,7 +90,7 @@ def __new__(cls, *args, **kwargs):
         if kwargs.get('freq') is not None:
             from pandas.core.resample import TimeGrouper
             cls = TimeGrouper
-        return super(Grouper, cls).__new__(cls)
+        return super().__new__(cls)
 
     def __init__(self, key=None, level=None, freq=None, axis=0, sort=False):
         self.key = key

pandas/io/msgpack/__init__.py

@@ -15,7 +15,7 @@ def __new__(cls, code, data):
             raise TypeError("data must be bytes")
         if not 0 <= code <= 127:
             raise ValueError("code must be 0~127")
-        return super(ExtType, cls).__new__(cls, code, data)
+        return super().__new__(cls, code, data)
 
 import os  # noqa
 

pandas/tests/arrays/test_array.py

@@ -222,9 +222,7 @@ def _from_sequence(cls, scalars, dtype=None, copy=False):
         if isinstance(scalars, (pd.Series, pd.Index)):
             raise TypeError
 
-        return super(DecimalArray2, cls)._from_sequence(
-            scalars, dtype=dtype, copy=copy
-        )
+        return super()._from_sequence(scalars, dtype=dtype, copy=copy)
 
 
 @pytest.mark.parametrize("box", [pd.Series, pd.Index])