From 413f11fa14bba69e8fcb401bd401837b67082223 Mon Sep 17 00:00:00 2001 From: Soyoun Kim Date: Sat, 14 Dec 2019 16:34:26 +0900 Subject: [PATCH 1/3] CLN: changed .format to f-string in pandas/core/indexes --- pandas/core/indexes/accessors.py | 11 +++--- pandas/core/indexes/category.py | 2 +- pandas/core/indexes/datetimelike.py | 4 +- pandas/core/indexes/datetimes.py | 16 +++----- pandas/core/indexes/frozen.py | 6 +-- pandas/core/indexes/interval.py | 48 ++++++++++-------------- pandas/core/indexes/multi.py | 57 ++++++++++++----------------- pandas/core/indexes/numeric.py | 7 ++-- pandas/core/indexes/period.py | 13 +++---- pandas/core/indexes/range.py | 9 ++--- pandas/core/indexes/timedeltas.py | 6 +-- 11 files changed, 73 insertions(+), 106 deletions(-) diff --git a/pandas/core/indexes/accessors.py b/pandas/core/indexes/accessors.py index e8d2ba85e08a6..ae27aad3dda08 100644 --- a/pandas/core/indexes/accessors.py +++ b/pandas/core/indexes/accessors.py @@ -26,8 +26,8 @@ class Properties(PandasDelegate, PandasObject, NoNewAttributesMixin): def __init__(self, data, orig): if not isinstance(data, ABCSeries): raise TypeError( - "cannot convert an object of type {0} to a " - "datetimelike index".format(type(data)) + f"cannot convert an object of type {type(data)} to a " + "datetimelike index" ) self._parent = data @@ -54,8 +54,7 @@ def _get_values(self): return DatetimeIndex(data, copy=False, name=self.name) raise TypeError( - "cannot convert an object of type {0} to a " - "datetimelike index".format(type(data)) + f"cannot convert an object of type {type(data)} to a datetimelike index" ) def _delegate_property_get(self, name): @@ -315,8 +314,8 @@ def __new__(cls, data): if not isinstance(data, ABCSeries): raise TypeError( - "cannot convert an object of type {0} to a " - "datetimelike index".format(type(data)) + f"cannot convert an object of type {type(data)} to a " + "datetimelike index" ) orig = data if is_categorical_dtype(data) else None diff --git a/pandas/core/indexes/category.py b/pandas/core/indexes/category.py index dc1cbb6014608..44478d00da9cf 100644 --- a/pandas/core/indexes/category.py +++ b/pandas/core/indexes/category.py @@ -893,7 +893,7 @@ def _add_comparison_methods(cls): """ add in comparison methods """ def _make_compare(op): - opname = "__{op}__".format(op=op.__name__) + opname = f"__{op.__name__}__" def _evaluate_compare(self, other): with np.errstate(all="ignore"): diff --git a/pandas/core/indexes/datetimelike.py b/pandas/core/indexes/datetimelike.py index eb3728c1e3bd2..50dbddec5c8b2 100644 --- a/pandas/core/indexes/datetimelike.py +++ b/pandas/core/indexes/datetimelike.py @@ -137,7 +137,7 @@ def wrapper(self, other): return result wrapper.__doc__ = op.__doc__ - wrapper.__name__ = "__{}__".format(op.__name__) + wrapper.__name__ = f"__{op.__name__}__" return wrapper @property @@ -677,7 +677,7 @@ def _summary(self, name=None): name = type(self).__name__ result = f"{name}: {len(self)} entries{index_summary}" if self.freq: - result += "\nFreq: %s" % self.freqstr + result += f"\nFreq: {self.freqstr}" # display as values, not quoted result = result.replace("'", "") diff --git a/pandas/core/indexes/datetimes.py b/pandas/core/indexes/datetimes.py index cafa2e03f23d0..523c434cb7377 100644 --- a/pandas/core/indexes/datetimes.py +++ b/pandas/core/indexes/datetimes.py @@ -247,10 +247,8 @@ def __new__( if is_scalar(data): raise TypeError( - "{cls}() must be called with a " - "collection of some kind, {data} was passed".format( - cls=cls.__name__, data=repr(data) - ) + f"{cls.__name__}() must be called with a " + f"collection of some kind, {repr(data)} was passed" ) # - Cases checked above all return/raise before reaching here - # @@ -973,9 +971,7 @@ def get_loc(self, key, method=None, tolerance=None): elif isinstance(key, timedelta): # GH#20464 raise TypeError( - "Cannot index {cls} with {other}".format( - cls=type(self).__name__, other=type(key).__name__ - ) + f"Cannot index {type(self).__name__} with {type(key).__name__}" ) if isinstance(key, time): @@ -1577,13 +1573,13 @@ def bdate_range( weekmask = weekmask or "Mon Tue Wed Thu Fri" freq = prefix_mapping[freq](holidays=holidays, weekmask=weekmask) except (KeyError, TypeError): - msg = "invalid custom frequency string: {freq}".format(freq=freq) + msg = f"invalid custom frequency string: {freq}" raise ValueError(msg) elif holidays or weekmask: msg = ( "a custom frequency string is required when holidays or " - "weekmask are passed, got frequency {freq}" - ).format(freq=freq) + f"weekmask are passed, got frequency {freq}" + ) raise ValueError(msg) return date_range( diff --git a/pandas/core/indexes/frozen.py b/pandas/core/indexes/frozen.py index 27f88933f9998..fd8ab74ed4920 100644 --- a/pandas/core/indexes/frozen.py +++ b/pandas/core/indexes/frozen.py @@ -93,11 +93,7 @@ def __hash__(self): def _disabled(self, *args, **kwargs): """This method will not function because object is immutable.""" - raise TypeError( - "'{cls}' does not support mutable operations.".format( - cls=type(self).__name__ - ) - ) + raise TypeError(f"'{type(self).__name__}' does not support mutable operations.") def __str__(self) -> str: return pprint_thing(self, quote_strings=True, escape_chars=("\t", "\r", "\n")) diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py index b1f67eeab903d..2b9ea4f9c03a9 100644 --- a/pandas/core/indexes/interval.py +++ b/pandas/core/indexes/interval.py @@ -154,10 +154,10 @@ def func(intvidx_self, other, sort=False): common_subtype = find_common_type(subtypes) if is_object_dtype(common_subtype): msg = ( - "can only do {op} between two IntervalIndex " + f"can only do {self.op_name} between two IntervalIndex " "objects that have compatible dtypes" ) - raise TypeError(msg.format(op=self.op_name)) + raise TypeError(msg) return setop(intvidx_self, other, sort) @@ -432,10 +432,8 @@ def closed(self): ) def set_closed(self, closed): if closed not in _VALID_CLOSED: - msg = "invalid option for 'closed': {closed}" - raise ValueError(msg.format(closed=closed)) + raise ValueError(f"invalid option for 'closed': {closed}") - # return self._shallow_copy(closed=closed) array = self._data.set_closed(closed) return self._simple_new(array, self.name) @@ -762,12 +760,12 @@ def _maybe_convert_i8(self, key): # ensure consistency with IntervalIndex subtype subtype = self.dtype.subtype - msg = ( - "Cannot index an IntervalIndex of subtype {subtype} with " - "values of dtype {other}" - ) + if not is_dtype_equal(subtype, key_dtype): - raise ValueError(msg.format(subtype=subtype, other=key_dtype)) + raise ValueError( + f"Cannot index an IntervalIndex of subtype {subtype} with " + f"values of dtype {key_dtype}" + ) return key_i8 @@ -776,8 +774,8 @@ def _check_method(self, method): return if method in ["bfill", "backfill", "pad", "ffill", "nearest"]: - msg = "method {method} not yet implemented for IntervalIndex" - raise NotImplementedError(msg.format(method=method)) + msg = f"method {method} not yet implemented for IntervalIndex" + raise NotImplementedError(msg) raise ValueError("Invalid fill method") @@ -1165,23 +1163,21 @@ def _format_data(self, name=None): summary = "[]" elif n == 1: first = formatter(self[0]) - summary = "[{first}]".format(first=first) + summary = f"[{first}]" elif n == 2: first = formatter(self[0]) last = formatter(self[-1]) - summary = "[{first}, {last}]".format(first=first, last=last) + summary = f"[{first}, {last}]" else: if n > max_seq_items: n = min(max_seq_items // 2, 10) head = [formatter(x) for x in self[:n]] tail = [formatter(x) for x in self[-n:]] - summary = "[{head} ... {tail}]".format( - head=", ".join(head), tail=", ".join(tail) - ) + summary = f"[{', '.join(head)} ... {', '.join(tail)}]" else: tail = [formatter(x) for x in self] - summary = "[{tail}]".format(tail=", ".join(tail)) + summary = f"[{', '.join(tail)}]" return summary + "," + self._format_space() @@ -1189,12 +1185,12 @@ def _format_attrs(self): attrs = [("closed", repr(self.closed))] if self.name is not None: attrs.append(("name", default_pprint(self.name))) - attrs.append(("dtype", "'{dtype}'".format(dtype=self.dtype))) + attrs.append(("dtype", f"'{self.dtype}'")) return attrs def _format_space(self): space = " " * (len(type(self).__name__) + 1) - return "\n{space}".format(space=space) + return f"\n{space}" # -------------------------------------------------------------------- @@ -1490,25 +1486,21 @@ def interval_range( ) if not _is_valid_endpoint(start): - msg = "start must be numeric or datetime-like, got {start}" - raise ValueError(msg.format(start=start)) + raise ValueError(f"start must be numeric or datetime-like, got {start}") elif not _is_valid_endpoint(end): - msg = "end must be numeric or datetime-like, got {end}" - raise ValueError(msg.format(end=end)) + raise ValueError(f"end must be numeric or datetime-like, got {end}") if is_float(periods): periods = int(periods) elif not is_integer(periods) and periods is not None: - msg = "periods must be a number, got {periods}" - raise TypeError(msg.format(periods=periods)) + raise TypeError(f"periods must be a number, got {periods}") if freq is not None and not is_number(freq): try: freq = to_offset(freq) except ValueError: raise ValueError( - "freq must be numeric or convertible to " - "DateOffset, got {freq}".format(freq=freq) + f"freq must be numeric or convertible to DateOffset, got {freq}" ) # verify type compatibility diff --git a/pandas/core/indexes/multi.py b/pandas/core/indexes/multi.py index 7b0cc871cbcbc..459d1fd19738d 100644 --- a/pandas/core/indexes/multi.py +++ b/pandas/core/indexes/multi.py @@ -343,35 +343,26 @@ def _verify_integrity(self, codes=None, levels=None): for i, (level, level_codes) in enumerate(zip(levels, codes)): if len(level_codes) != codes_length: raise ValueError( - "Unequal code lengths: %s" % ([len(code_) for code_ in codes]) + f"Unequal code lengths: {[len(code_) for code_ in codes]}" ) if len(level_codes) and level_codes.max() >= len(level): - msg = ( - "On level {level}, code max ({max_code}) >= length of " - "level ({level_len}). NOTE: this index is in an " - "inconsistent state".format( - level=i, max_code=level_codes.max(), level_len=len(level) - ) - ) - raise ValueError(msg) - if len(level_codes) and level_codes.min() < -1: raise ValueError( - "On level {level}, code value ({code})" - " < -1".format(level=i, code=level_codes.min()) + f"On level {i}, code max ({level_codes.max()}) >= length of " + f"level ({len(level)}). NOTE: this index is in an " + "inconsistent state" ) + if len(level_codes) and level_codes.min() < -1: + raise ValueError(f"On level {i}, code value ({level_codes.min()}) < -1") if not level.is_unique: raise ValueError( - "Level values must be unique: {values} on " - "level {level}".format(values=list(level), level=i) + f"Level values must be unique: {list(level)} on level {i}" ) if self.sortorder is not None: if self.sortorder > self._lexsort_depth(): raise ValueError( - "Value for sortorder must be inferior or equal " - "to actual lexsort_depth: " - "sortorder {sortorder} with lexsort_depth {lexsort_depth}".format( - sortorder=self.sortorder, lexsort_depth=self._lexsort_depth() - ) + "Value for sortorder must be inferior or equal to actual " + f"lexsort_depth: sortorder {self.sortorder} " + f"with lexsort_depth {self._lexsort_depth()}" ) codes = [ @@ -1241,7 +1232,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(type(self).__name__) + f"{type(self).__name__}.name must be a hashable type" ) self._names[lev] = name @@ -1312,8 +1303,8 @@ def _get_level_number(self, level) -> int: # Note: levels are zero-based elif level >= self.nlevels: raise IndexError( - "Too many levels: Index has only %d levels, " - "not %d" % (self.nlevels, level + 1) + f"Too many levels: Index has only {self.nlevels} levels, " + f"not {level + 1}" ) return level @@ -1465,7 +1456,7 @@ def dropna(self, how="any"): elif how == "all": indexer = np.all(nans, axis=0) else: - raise ValueError("invalid how option: {0}".format(how)) + raise ValueError(f"invalid how option: {how}") new_codes = [level_codes[~indexer] for level_codes in self.codes] return self.copy(codes=new_codes, deep=True) @@ -2103,7 +2094,7 @@ def drop(self, codes, level=None, errors="raise"): loc = loc.nonzero()[0] inds.extend(loc) else: - msg = "unsupported indexer of type {}".format(type(loc)) + msg = f"unsupported indexer of type {type(loc)}" raise AssertionError(msg) except KeyError: if errors != "ignore": @@ -2330,7 +2321,7 @@ def _convert_listlike_indexer(self, keyarr, kind=None): check = self.levels[0].get_indexer(keyarr) mask = check == -1 if mask.any(): - raise KeyError("%s not in index" % keyarr[mask]) + raise KeyError(f"{keyarr[mask]} not in index") return indexer, keyarr @@ -2600,8 +2591,7 @@ def _maybe_to_slice(loc): keylen = len(key) if self.nlevels < keylen: raise KeyError( - "Key length ({0}) exceeds index depth ({1})" - "".format(keylen, self.nlevels) + f"Key length ({keylen}) exceeds index depth ({self.nlevels})" ) if keylen == self.nlevels and self.is_unique: @@ -2917,9 +2907,8 @@ def get_locs(self, seq): true_slices = [i for (i, s) in enumerate(com.is_true_slices(seq)) if s] if true_slices and true_slices[-1] >= self.lexsort_depth: raise UnsortedIndexError( - "MultiIndex slicing requires the index " - "to be lexsorted: slicing on levels {0}, " - "lexsort depth {1}".format(true_slices, self.lexsort_depth) + "MultiIndex slicing requires the index to be lexsorted: slicing " + f"on levels {true_slices}, lexsort depth {self.lexsort_depth}" ) # indexer # this is the list of all values that we want to select @@ -3261,10 +3250,10 @@ def astype(self, dtype, copy=True): msg = "> 1 ndim Categorical are not supported at this time" raise NotImplementedError(msg) elif not is_object_dtype(dtype): - msg = ( - "Setting {cls} dtype to anything other than object is not supported" - ).format(cls=type(self)) - raise TypeError(msg) + raise TypeError( + f"Setting {type(self)} dtype to anything other " + "than object is not supported" + ) elif copy is True: return self._shallow_copy() return self diff --git a/pandas/core/indexes/numeric.py b/pandas/core/indexes/numeric.py index 536a1fb6ae243..048bff46759bc 100644 --- a/pandas/core/indexes/numeric.py +++ b/pandas/core/indexes/numeric.py @@ -381,11 +381,10 @@ def inferred_type(self) -> str: def astype(self, dtype, copy=True): dtype = pandas_dtype(dtype) if needs_i8_conversion(dtype): - msg = ( - "Cannot convert Float64Index to dtype {dtype}; integer " + raise TypeError( + f"Cannot convert Float64Index to dtype {dtype}; integer " "values are required for conversion" - ).format(dtype=dtype) - raise TypeError(msg) + ) elif is_integer_dtype(dtype) and not is_extension_array_dtype(dtype): # TODO(jreback); this can change once we have an EA Index type # GH 13149 diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py index 15639d4436d5f..ac751128ef912 100644 --- a/pandas/core/indexes/period.py +++ b/pandas/core/indexes/period.py @@ -183,9 +183,8 @@ def __new__( if not set(fields).issubset(valid_field_set): raise TypeError( - "__new__() got an unexpected keyword argument {}".format( - list(set(fields) - valid_field_set)[0] - ) + "__new__() got an unexpected keyword argument " + f"{list(set(fields) - valid_field_set)[0]}" ) if name is None and hasattr(data, "name"): @@ -445,10 +444,10 @@ def __array_wrap__(self, result, context=None): return Index(result, name=name) elif isinstance(func, np.ufunc): if "M->M" not in func.types: - msg = "ufunc '{0}' not supported for the PeriodIndex" + msg = f"ufunc '{func.__name__}' not supported for the PeriodIndex" # This should be TypeError, but TypeError cannot be raised # from here because numpy catches. - raise ValueError(msg.format(func.__name__)) + raise ValueError(msg) if is_bool_dtype(result): return result @@ -508,7 +507,7 @@ def searchsorted(self, value, side="left", sorter=None): try: value = Period(value, freq=self.freq).ordinal except DateParseError: - raise KeyError("Cannot interpret '{}' as period".format(value)) + raise KeyError(f"Cannot interpret '{value}' as period") return self._ndarray_values.searchsorted(value, side=side, sorter=sorter) @@ -656,7 +655,7 @@ def get_loc(self, key, method=None, tolerance=None): pass except DateParseError: # A string with invalid format - raise KeyError("Cannot interpret '{}' as period".format(key)) + raise KeyError(f"Cannot interpret '{key}' as period") try: key = Period(key, freq=self.freq) diff --git a/pandas/core/indexes/range.py b/pandas/core/indexes/range.py index f300cde3b5bcc..6ad70841a48b0 100644 --- a/pandas/core/indexes/range.py +++ b/pandas/core/indexes/range.py @@ -121,8 +121,8 @@ def from_range(cls, data, name=None, dtype=None): """ if not isinstance(data, range): raise TypeError( - "{0}(...) must be called with object coercible to a " - "range, {1} was passed".format(cls.__name__, repr(data)) + f"{cls.__name__}(...) must be called with object coercible to a " + f"range, {repr(data)} was passed" ) cls._validate_dtype(dtype) @@ -695,8 +695,7 @@ def __getitem__(self, key): return self._range[new_key] except IndexError: raise IndexError( - "index {key} is out of bounds for axis 0 " - "with size {size}".format(key=key, size=len(self)) + f"index {key} is out of bounds for axis 0 with size {len(self)}" ) elif is_scalar(key): raise IndexError( @@ -796,7 +795,7 @@ def _evaluate_numeric_binop(self, other): return op(self._int64index, other) # TODO: Do attrs get handled reliably? - name = "__{name}__".format(name=op.__name__) + name = f"__{op.__name__}__" return compat.set_function_name(_evaluate_numeric_binop, name, cls) cls.__add__ = _make_evaluate_binop(operator.add) diff --git a/pandas/core/indexes/timedeltas.py b/pandas/core/indexes/timedeltas.py index 16db4106552a9..889075ebe4e31 100644 --- a/pandas/core/indexes/timedeltas.py +++ b/pandas/core/indexes/timedeltas.py @@ -166,10 +166,8 @@ def __new__( if is_scalar(data): raise TypeError( - "{cls}() must be called with a " - "collection of some kind, {data} was passed".format( - cls=cls.__name__, data=repr(data) - ) + f"{cls.__name__}() must be called with a " + f"collection of some kind, {repr(data)} was passed" ) if unit in {"Y", "y", "M"}: From c2e4d3f7e345d2d0c19b8a8463f60a5aecd538ed Mon Sep 17 00:00:00 2001 From: Soyoun Kim Date: Sat, 14 Dec 2019 21:04:49 +0900 Subject: [PATCH 2/3] Putted remved line back. Complex statement separated into variable. --- pandas/core/indexes/interval.py | 1 + pandas/core/indexes/period.py | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/pandas/core/indexes/interval.py b/pandas/core/indexes/interval.py index 2b9ea4f9c03a9..f046f0d89c428 100644 --- a/pandas/core/indexes/interval.py +++ b/pandas/core/indexes/interval.py @@ -434,6 +434,7 @@ def set_closed(self, closed): if closed not in _VALID_CLOSED: raise ValueError(f"invalid option for 'closed': {closed}") + # return self._shallow_copy(closed=closed) array = self._data.set_closed(closed) return self._simple_new(array, self.name) diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py index ac751128ef912..6c058aacb915f 100644 --- a/pandas/core/indexes/period.py +++ b/pandas/core/indexes/period.py @@ -182,9 +182,9 @@ def __new__( } if not set(fields).issubset(valid_field_set): + argument = list(set(fields) - valid_field_set)[0] raise TypeError( - "__new__() got an unexpected keyword argument " - f"{list(set(fields) - valid_field_set)[0]}" + f"__new__() got an unexpected keyword argument {argument}" ) if name is None and hasattr(data, "name"): From 934e018c48f7307513603978a39ccadce33023a1 Mon Sep 17 00:00:00 2001 From: Soyoun Kim Date: Sat, 14 Dec 2019 21:34:40 +0900 Subject: [PATCH 3/3] Applied black pandas --- pandas/core/indexes/period.py | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/pandas/core/indexes/period.py b/pandas/core/indexes/period.py index 6c058aacb915f..979ab275f64f2 100644 --- a/pandas/core/indexes/period.py +++ b/pandas/core/indexes/period.py @@ -183,9 +183,7 @@ def __new__( if not set(fields).issubset(valid_field_set): argument = list(set(fields) - valid_field_set)[0] - raise TypeError( - f"__new__() got an unexpected keyword argument {argument}" - ) + raise TypeError(f"__new__() got an unexpected keyword argument {argument}") if name is None and hasattr(data, "name"): name = data.name