Changed x.__class__ to type(x)

Author: MomIsBestFriend

pandas/_libs/internals.pyx

@@ -54,7 +54,7 @@ cdef class BlockPlacement:
         else:
             v = self._as_array
 
-        return f'{self.__class__.__name__}({v})'
+        return f'{type(self).__name__}({v})'
 
     def __repr__(self) -> str:
         return str(self)

pandas/_libs/tslibs/offsets.pyx

@@ -363,7 +363,7 @@ class _BaseOffset:
         attrs = [(k, v) for k, v in all_paras.items()
                  if (k not in exclude) and (k[0] != '_')]
         attrs = sorted(set(attrs))
-        params = tuple([str(self.__class__)] + attrs)
+        params = tuple([str(type(self))] + attrs)
         return params
 
     @property

pandas/core/arrays/base.py

@@ -923,7 +923,7 @@ def __repr__(self) -> str:
         data = format_object_summary(
             self, self._formatter(), indent_for_name=False
         ).rstrip(", \n")
-        class_name = "<{}>\n".format(self.__class__.__name__)
+        class_name = "<{}>\n".format(type(self).__name__)
         return template.format(
             class_name=class_name, data=data, length=len(self), dtype=self.dtype
         )

pandas/core/arrays/interval.py

@@ -870,7 +870,7 @@ def __repr__(self) -> str:
         # repr does. So we include a newline in our template, and strip
         # any trailing newlines from format_object_summary
         data = self._format_data()
-        class_name = "<{}>\n".format(self.__class__.__name__)
+        class_name = "<{}>\n".format(type(self).__name__)
         return template.format(
             class_name=class_name,
             data=data,
@@ -880,7 +880,7 @@ def __repr__(self) -> str:
         )
 
     def _format_space(self):
-        space = " " * (len(self.__class__.__name__) + 1)
+        space = " " * (len(type(self).__name__) + 1)
         return "\n{space}".format(space=space)
 
     @property

pandas/core/base.py

@@ -51,7 +51,7 @@ class PandasObject(DirNamesMixin):
     @property
     def _constructor(self):
         """class constructor (for this class it's just `__class__`"""
-        return self.__class__
+        return type(self)
 
     def __repr__(self) -> str:
         """
@@ -1185,7 +1185,7 @@ def _reduce(
         if func is None:
             raise TypeError(
                 "{klass} cannot perform the operation {op}".format(
-                    klass=self.__class__.__name__, op=name
+                    klass=type(self).__name__, op=name
                 )
             )
         return func(skipna=skipna, **kwds)

pandas/core/common.py

@@ -317,7 +317,7 @@ def get_callable_name(obj):
         return get_callable_name(obj.func)
     # fall back to class name
     if hasattr(obj, "__call__"):
-        return obj.__class__.__name__
+        return type(obj).__name__
     # everything failed (probably because the argument
     # wasn't actually callable); we return None
     # instead of the empty string in this case to allow

pandas/core/computation/expr.py

@@ -435,7 +435,7 @@ def visit(self, node, **kwargs):
                     e.msg = "Python keyword not valid identifier in numexpr query"
                 raise e
 
-        method = "visit_" + node.__class__.__name__
+        method = "visit_" + type(node).__name__
         visitor = getattr(self, method)
         return visitor(node, **kwargs)
 

pandas/core/computation/ops.py

@@ -145,7 +145,7 @@ def type(self):
     def raw(self) -> str:
         return pprint_thing(
             "{0}(name={1!r}, type={2})"
-            "".format(self.__class__.__name__, self.name, self.type)
+            "".format(type(self).__name__, self.name, self.type)
         )
 
     @property

pandas/core/computation/pytables.py

@@ -440,7 +440,7 @@ def visit_Attribute(self, node, **kwargs):
         attr = node.attr
         value = node.value
 
-        ctx = node.ctx.__class__
+        ctx = type(node.ctx)
         if ctx == ast.Load:
             # resolve the value
             resolved = self.visit(value)

pandas/core/dtypes/dtypes.py

@@ -420,7 +420,7 @@ def __repr__(self) -> str_type:
         if self.categories is None:
             data = "None, "
         else:
-            data = self.categories._format_data(name=self.__class__.__name__)
+            data = self.categories._format_data(name=type(self).__name__)
         return tpl.format(data=data, ordered=self._ordered)
 
     @staticmethod

pandas/core/generic.py

@@ -253,7 +253,7 @@ def _validate_dtype(self, dtype):
             if dtype.kind == "V":
                 raise NotImplementedError(
                     "compound dtypes are not implemented"
-                    " in the {0} constructor".format(self.__class__.__name__)
+                    " in the {0} constructor".format(type(self).__name__)
                 )
 
         return dtype
@@ -1536,7 +1536,7 @@ def __nonzero__(self):
         raise ValueError(
             "The truth value of a {0} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all().".format(
-                self.__class__.__name__
+                type(self).__name__
             )
         )
 
@@ -1561,7 +1561,7 @@ def bool(self):
         elif is_scalar(v):
             raise ValueError(
                 "bool cannot act on a non-boolean single element "
-                "{0}".format(self.__class__.__name__)
+                "{0}".format(type(self).__name__)
             )
 
         self.__nonzero__()
@@ -1867,7 +1867,7 @@ def _drop_labels_or_levels(self, keys, axis=0):
     def __hash__(self):
         raise TypeError(
             "{0!r} objects are mutable, thus they cannot be"
-            " hashed".format(self.__class__.__name__)
+            " hashed".format(type(self).__name__)
         )
 
     def __iter__(self):
@@ -2061,7 +2061,7 @@ def __repr__(self) -> str:
         # string representation based upon iterating over self
         # (since, by definition, `PandasContainers` are iterable)
         prepr = "[%s]" % ",".join(map(pprint_thing, self))
-        return f"{self.__class__.__name__}({prepr})"
+        return f"{type(self).__name__}({prepr})"
 
     def _repr_latex_(self):
         """

pandas/core/groupby/generic.py

@@ -473,7 +473,7 @@ def _transform_general(self, func, *args, **kwargs):
         """
         Transform with a non-str `func`.
         """
-        klass = self._selected_obj.__class__
+        klass = type(self._selected_obj)
 
         results = []
         for name, group in self:

pandas/core/groupby/grouper.py

@@ -213,7 +213,7 @@ def __repr__(self) -> str:
             if getattr(self, attr_name) is not None
         )
         attrs = ", ".join(attrs_list)
-        cls_name = self.__class__.__name__
+        cls_name = type(self).__name__
         return f"{cls_name}({attrs})"
 
 

pandas/core/indexes/base.py

@@ -826,7 +826,7 @@ def take(self, indices, axis=0, allow_fill=True, fill_value=None, **kwargs):
         else:
             if allow_fill and fill_value is not None:
                 msg = "Unable to fill values because {0} cannot contain NA"
-                raise ValueError(msg.format(self.__class__.__name__))
+                raise ValueError(msg.format(type(self).__name__))
             taken = self.values.take(indices)
         return self._shallow_copy(taken)
 
@@ -959,7 +959,7 @@ def __repr__(self):
         """
         Return a string representation for this object.
         """
-        klass = self.__class__.__name__
+        klass = type(self).__name__
         data = self._format_data()
         attrs = self._format_attrs()
         space = self._format_space()
@@ -1311,7 +1311,7 @@ def _set_names(self, values, level=None):
         for name in values:
             if not is_hashable(name):
                 raise TypeError(
-                    "{}.name must be a hashable type".format(self.__class__.__name__)
+                    "{}.name must be a hashable type".format(type(self).__name__)
                 )
         self.name = values[0]
 
@@ -1818,7 +1818,7 @@ def is_all_dates(self) -> bool:
     def __reduce__(self):
         d = dict(data=self._data)
         d.update(self._get_attributes_dict())
-        return _new_Index, (self.__class__, d), None
+        return _new_Index, (type(self), d), None
 
     def __setstate__(self, state):
         """
@@ -2314,7 +2314,7 @@ def __nonzero__(self):
         raise ValueError(
             "The truth value of a {0} is ambiguous. "
             "Use a.empty, a.bool(), a.item(), a.any() or a.all().".format(
-                self.__class__.__name__
+                type(self).__name__
             )
         )
 

pandas/core/indexes/datetimes.py

@@ -423,7 +423,7 @@ def __reduce__(self):
 
         d = dict(data=self._data)
         d.update(self._get_attributes_dict())
-        return _new_DatetimeIndex, (self.__class__, d), None
+        return _new_DatetimeIndex, (type(self), d), None
 
     def __setstate__(self, state):
         """Necessary for making this object picklable"""

pandas/core/indexes/frozen.py

@@ -90,7 +90,7 @@ def __mul__(self, other):
     __imul__ = __mul__
 
     def __reduce__(self):
-        return self.__class__, (list(self),)
+        return type(self), (list(self),)
 
     def __hash__(self):
         return hash(tuple(self))
@@ -99,15 +99,15 @@ def _disabled(self, *args, **kwargs):
         """This method will not function because object is immutable."""
         raise TypeError(
             "'{cls}' does not support mutable operations.".format(
-                cls=self.__class__.__name__
+                cls=type(self).__name__
             )
         )
 
     def __str__(self) -> str:
         return pprint_thing(self, quote_strings=True, escape_chars=("\t", "\r", "\n"))
 
     def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({str(self)})"
+        return f"{type(self).__name__}({str(self)})"
 
     __setitem__ = __setslice__ = __delitem__ = __delslice__ = _disabled
     pop = append = extend = remove = sort = insert = _disabled
@@ -132,7 +132,7 @@ def __new__(cls, data, dtype=None, copy=False):
     def _disabled(self, *args, **kwargs):
         """This method will not function because object is immutable."""
         raise TypeError(
-            "'{cls}' does not support mutable operations.".format(cls=self.__class__)
+            "'{cls}' does not support mutable operations.".format(cls=type(self))
         )
 
     __setitem__ = __setslice__ = __delitem__ = __delslice__ = _disabled

pandas/core/indexes/interval.py

@@ -497,7 +497,7 @@ def __array_wrap__(self, result, context=None):
     def __reduce__(self):
         d = dict(left=self.left, right=self.right)
         d.update(self._get_attributes_dict())
-        return _new_IntervalIndex, (self.__class__, d), None
+        return _new_IntervalIndex, (type(self), d), None
 
     @Appender(_index_shared_docs["copy"])
     def copy(self, deep=False, name=None):
@@ -512,7 +512,7 @@ def copy(self, deep=False, name=None):
 
     @Appender(_index_shared_docs["astype"])
     def astype(self, dtype, copy=True):
-        with rewrite_exception("IntervalArray", self.__class__.__name__):
+        with rewrite_exception("IntervalArray", type(self).__name__):
             new_values = self.values.astype(dtype, copy=copy)
         if is_interval_dtype(new_values):
             return self._shallow_copy(new_values.left, new_values.right)
@@ -1205,7 +1205,7 @@ def _format_attrs(self):
         return attrs
 
     def _format_space(self):
-        space = " " * (len(self.__class__.__name__) + 1)
+        space = " " * (len(type(self).__name__) + 1)
         return "\n{space}".format(space=space)
 
     # --------------------------------------------------------------------

pandas/core/indexes/multi.py

@@ -1274,9 +1274,7 @@ def _set_names(self, names, level=None, validate=True):
                 # All items in 'names' need to be hashable:
                 if not is_hashable(name):
                     raise TypeError(
-                        "{}.name must be a hashable type".format(
-                            self.__class__.__name__
-                        )
+                        "{}.name must be a hashable type".format(type(self).__name__)
                     )
             self._names[lev] = name
 
@@ -1996,7 +1994,7 @@ def __reduce__(self):
             sortorder=self.sortorder,
             names=list(self.names),
         )
-        return ibase._new_Index, (self.__class__, d), None
+        return ibase._new_Index, (type(self), d), None
 
     def __setstate__(self, state):
         """Necessary for making this object picklable"""
@@ -3350,7 +3348,7 @@ def astype(self, dtype, copy=True):
         elif not is_object_dtype(dtype):
             msg = (
                 "Setting {cls} dtype to anything other than object is not supported"
-            ).format(cls=self.__class__)
+            ).format(cls=type(self))
             raise TypeError(msg)
         elif copy is True:
             return self._shallow_copy()

pandas/core/indexes/range.py

@@ -196,7 +196,7 @@ def _get_data_as_items(self):
     def __reduce__(self):
         d = self._get_attributes_dict()
         d.update(dict(self._get_data_as_items()))
-        return ibase._new_Index, (self.__class__, d), None
+        return ibase._new_Index, (type(self), d), None
 
     # --------------------------------------------------------------------
     # Rendering Methods

pandas/core/internals/blocks.py

@@ -257,11 +257,11 @@ def make_block_same_class(self, values, placement=None, ndim=None):
             placement = self.mgr_locs
         if ndim is None:
             ndim = self.ndim
-        return make_block(values, placement=placement, ndim=ndim, klass=self.__class__)
+        return make_block(values, placement=placement, ndim=ndim, klass=type(self))
 
     def __repr__(self) -> str:
         # don't want to print out all of the items here
-        name = pprint_thing(self.__class__.__name__)
+        name = pprint_thing(type(self).__name__)
         if self._is_single_block:
 
             result = "{name}: {len} dtype: {dtype}".format(

pandas/core/internals/concat.py

@@ -122,7 +122,7 @@ def __init__(self, block, shape, indexers=None):
 
     def __repr__(self) -> str:
         return "{name}({block!r}, {indexers})".format(
-            name=self.__class__.__name__, block=self.block, indexers=self.indexers
+            name=type(self).__name__, block=self.block, indexers=self.indexers
         )
 
     @cache_readonly

pandas/core/internals/managers.py

@@ -319,7 +319,7 @@ def __len__(self) -> int:
         return len(self.items)
 
     def __repr__(self) -> str:
-        output = pprint_thing(self.__class__.__name__)
+        output = pprint_thing(type(self).__name__)
         for i, ax in enumerate(self.axes):
             if i == 0:
                 output += "\nItems: {ax}".format(ax=ax)

pandas/core/resample.py

@@ -96,7 +96,7 @@ def __str__(self) -> str:
             if getattr(self.groupby, k, None) is not None
         )
         return "{klass} [{attrs}]".format(
-            klass=self.__class__.__name__, attrs=", ".join(attrs)
+            klass=type(self).__name__, attrs=", ".join(attrs)
         )
 
     def __getattr__(self, attr):

pandas/core/series.py

@@ -273,9 +273,7 @@ def __init__(
             elif is_extension_array_dtype(data):
                 pass
             elif isinstance(data, (set, frozenset)):
-                raise TypeError(
-                    "{0!r} type is unordered".format(data.__class__.__name__)
-                )
+                raise TypeError("{0!r} type is unordered".format(type(data).__name__))
             elif isinstance(data, ABCSparseArray):
                 # handle sparse passed here (and force conversion)
                 data = data.to_dense()
@@ -1590,7 +1588,7 @@ def to_string(
             raise AssertionError(
                 "result must be of type unicode, type"
                 " of result is {0!r}"
-                "".format(result.__class__.__name__)
+                "".format(type(result).__name__)
             )
 
         if buf is None:

pandas/core/window/rolling.py

@@ -205,7 +205,7 @@ def _get_window(self, other=None, win_type: Optional[str] = None) -> int:
 
     @property
     def _window_type(self) -> str:
-        return self.__class__.__name__
+        return type(self).__name__
 
     def __repr__(self) -> str:
         """