Fix

pandas/tests/arrays/test_timedeltas.py

@@ -81,7 +81,7 @@ def test_from_sequence_dtype(self):
 
  @pytest.mark.parametrize("dtype", [int, np.int32, np.int64, "uint32", "uint64"])
  def test_astype_int(self, dtype):
- arr = TimedeltaArray._from_sequence([pd.Timedelta("1H"), pd.Timedelta("2H")])
+ arr = TimedeltaArray._from_sequence([Timedelta("1H"), Timedelta("2H")])
  result = arr.astype(dtype)
 
  if np.dtype(dtype).kind == "u":
@@ -95,15 +95,15 @@ def test_astype_int(self, dtype):
 
  def test_setitem_clears_freq(self):
  a = TimedeltaArray(pd.timedelta_range("1H", periods=2, freq="H"))
- a[0] = pd.Timedelta("1H")
+ a[0] = Timedelta("1H")
  assert a.freq is None
 
  @pytest.mark.parametrize(
  "obj",
  [
- pd.Timedelta(seconds=1),
- pd.Timedelta(seconds=1).to_timedelta64(),
- pd.Timedelta(seconds=1).to_pytimedelta(),
+ Timedelta(seconds=1),
+ Timedelta(seconds=1).to_timedelta64(),
+ Timedelta(seconds=1).to_pytimedelta(),
  ],
  )
  def test_setitem_objects(self, obj):
@@ -112,7 +112,7 @@ def test_setitem_objects(self, obj):
  arr = TimedeltaArray(tdi, freq=tdi.freq)
 
  arr[0] = obj
- assert arr[0] == pd.Timedelta(seconds=1)
+ assert arr[0] == Timedelta(seconds=1)
 
  @pytest.mark.parametrize(
  "other",
@@ -206,11 +206,11 @@ def test_min_max(self):
  arr = TimedeltaArray._from_sequence(["3H", "3H", "NaT", "2H", "5H", "4H"])
 
  result = arr.min()
- expected = pd.Timedelta("2H")
+ expected = Timedelta("2H")
  assert result == expected
 
  result = arr.max()
- expected = pd.Timedelta("5H")
+ expected = Timedelta("5H")
  assert result == expected
 
  result = arr.min(skipna=False)
@@ -224,12 +224,12 @@ def test_sum(self):
  arr = tdi.array
 
  result = arr.sum(skipna=True)
- expected = pd.Timedelta(hours=17)
- assert isinstance(result, pd.Timedelta)
+ expected = Timedelta(hours=17)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = tdi.sum(skipna=True)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = arr.sum(skipna=False)
@@ -245,11 +245,11 @@ def test_sum(self):
  assert result is pd.NaT
 
  result = arr.sum(min_count=1)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = tdi.sum(min_count=1)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  def test_npsum(self):
@@ -258,12 +258,12 @@ def test_npsum(self):
  arr = tdi.array
 
  result = np.sum(tdi)
- expected = pd.Timedelta(hours=17)
- assert isinstance(result, pd.Timedelta)
+ expected = Timedelta(hours=17)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = np.sum(arr)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  def test_sum_2d_skipna_false(self):
@@ -276,15 +276,15 @@ def test_sum_2d_skipna_false(self):
  assert result is pd.NaT
 
  result = tda.sum(axis=0, skipna=False)
- expected = pd.TimedeltaIndex([pd.Timedelta(seconds=12), pd.NaT])._values
+ expected = pd.TimedeltaIndex([Timedelta(seconds=12), pd.NaT])._values
  tm.assert_timedelta_array_equal(result, expected)
 
  result = tda.sum(axis=1, skipna=False)
  expected = pd.TimedeltaIndex(
  [
- pd.Timedelta(seconds=1),
- pd.Timedelta(seconds=5),
- pd.Timedelta(seconds=9),
+ Timedelta(seconds=1),
+ Timedelta(seconds=5),
+ Timedelta(seconds=9),
  pd.NaT,
  ]
  )._values
@@ -294,7 +294,7 @@ def test_sum_2d_skipna_false(self):
  @pytest.mark.parametrize(
  "add",
  [
- pd.Timedelta(0),
+ Timedelta(0),
  pd.Timestamp.now(),
  pd.Timestamp.now("UTC"),
  pd.Timestamp.now("Asia/Tokyo"),
@@ -305,17 +305,17 @@ def test_std(self, add):
  arr = tdi.array
 
  result = arr.std(skipna=True)
- expected = pd.Timedelta(hours=2)
- assert isinstance(result, pd.Timedelta)
+ expected = Timedelta(hours=2)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = tdi.std(skipna=True)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  if getattr(arr, "tz", None) is None:
  result = nanops.nanstd(np.asarray(arr), skipna=True)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = arr.std(skipna=False)
@@ -333,12 +333,12 @@ def test_median(self):
  arr = tdi.array
 
  result = arr.median(skipna=True)
- expected = pd.Timedelta(hours=2)
- assert isinstance(result, pd.Timedelta)
+ expected = Timedelta(hours=2)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = tdi.median(skipna=True)
- assert isinstance(result, pd.Timedelta)
+ assert isinstance(result, Timedelta)
  assert result == expected
 
  result = arr.median(skipna=False)
@@ -352,7 +352,7 @@ def test_mean(self):
  arr = tdi._data
 
  # manually verified result
- expected = pd.Timedelta(arr.dropna()._ndarray.mean())
+ expected = Timedelta(arr.dropna()._ndarray.mean())
 
  result = arr.mean()
  assert result == expected
@@ -374,7 +374,7 @@ def test_mean_2d(self):
  tm.assert_timedelta_array_equal(result, expected)
 
  result = tda.mean(axis=1)
- expected = tda[:, 0] + pd.Timedelta(hours=12)
+ expected = tda[:, 0] + Timedelta(hours=12)
  tm.assert_timedelta_array_equal(result, expected)
 
  result = tda.mean(axis=None)

pandas/tests/series/indexing/test_indexing.py

@@ -133,10 +133,10 @@ def test_getitem_fancy(string_series, object_series):
 def test_type_promotion():
  # GH12599
  s = Series(dtype=object)
- s["a"] = pd.Timestamp("2016-01-01")
+ s["a"] = Timestamp("2016-01-01")
  s["b"] = 3.0
  s["c"] = "foo"
- expected = Series([pd.Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
+ expected = Series([Timestamp("2016-01-01"), 3.0, "foo"], index=["a", "b", "c"])
  tm.assert_series_equal(s, expected)
 
 
@@ -181,13 +181,13 @@ def test_series_box_timestamp():
  rng = pd.date_range("20090415", "20090519", freq="B")
  ser = Series(rng)
 
- assert isinstance(ser[5], pd.Timestamp)
+ assert isinstance(ser[5], Timestamp)
 
  rng = pd.date_range("20090415", "20090519", freq="B")
  ser = Series(rng, index=rng)
- assert isinstance(ser[5], pd.Timestamp)
+ assert isinstance(ser[5], Timestamp)
 
- assert isinstance(ser.iat[5], pd.Timestamp)
+ assert isinstance(ser.iat[5], Timestamp)
 
 
 def test_series_box_timedelta():
@@ -354,37 +354,37 @@ def test_setitem_with_tz(tz):
 
  # scalar
  s = orig.copy()
- s[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s[1] = Timestamp("2011-01-01", tz=tz)
  exp = Series(
  [
- pd.Timestamp("2016-01-01 00:00", tz=tz),
- pd.Timestamp("2011-01-01 00:00", tz=tz),
- pd.Timestamp("2016-01-01 02:00", tz=tz),
+ Timestamp("2016-01-01 00:00", tz=tz),
+ Timestamp("2011-01-01 00:00", tz=tz),
+ Timestamp("2016-01-01 02:00", tz=tz),
  ]
  )
  tm.assert_series_equal(s, exp)
 
  s = orig.copy()
- s.loc[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s.loc[1] = Timestamp("2011-01-01", tz=tz)
  tm.assert_series_equal(s, exp)
 
  s = orig.copy()
- s.iloc[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s.iloc[1] = Timestamp("2011-01-01", tz=tz)
  tm.assert_series_equal(s, exp)
 
  # vector
  vals = Series(
- [pd.Timestamp("2011-01-01", tz=tz), pd.Timestamp("2012-01-01", tz=tz)],
+ [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
  index=[1, 2],
  )
  assert vals.dtype == f"datetime64[ns, {tz}]"
 
  s[[1, 2]] = vals
  exp = Series(
  [
- pd.Timestamp("2016-01-01 00:00", tz=tz),
- pd.Timestamp("2011-01-01 00:00", tz=tz),
- pd.Timestamp("2012-01-01 00:00", tz=tz),
+ Timestamp("2016-01-01 00:00", tz=tz),
+ Timestamp("2011-01-01 00:00", tz=tz),
+ Timestamp("2012-01-01 00:00", tz=tz),
  ]
  )
  tm.assert_series_equal(s, exp)
@@ -406,37 +406,37 @@ def test_setitem_with_tz_dst():
 
  # scalar
  s = orig.copy()
- s[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s[1] = Timestamp("2011-01-01", tz=tz)
  exp = Series(
  [
- pd.Timestamp("2016-11-06 00:00-04:00", tz=tz),
- pd.Timestamp("2011-01-01 00:00-05:00", tz=tz),
- pd.Timestamp("2016-11-06 01:00-05:00", tz=tz),
+ Timestamp("2016-11-06 00:00-04:00", tz=tz),
+ Timestamp("2011-01-01 00:00-05:00", tz=tz),
+ Timestamp("2016-11-06 01:00-05:00", tz=tz),
  ]
  )
  tm.assert_series_equal(s, exp)
 
  s = orig.copy()
- s.loc[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s.loc[1] = Timestamp("2011-01-01", tz=tz)
  tm.assert_series_equal(s, exp)
 
  s = orig.copy()
- s.iloc[1] = pd.Timestamp("2011-01-01", tz=tz)
+ s.iloc[1] = Timestamp("2011-01-01", tz=tz)
  tm.assert_series_equal(s, exp)
 
  # vector
  vals = Series(
- [pd.Timestamp("2011-01-01", tz=tz), pd.Timestamp("2012-01-01", tz=tz)],
+ [Timestamp("2011-01-01", tz=tz), Timestamp("2012-01-01", tz=tz)],
  index=[1, 2],
  )
  assert vals.dtype == f"datetime64[ns, {tz}]"
 
  s[[1, 2]] = vals
  exp = Series(
  [
- pd.Timestamp("2016-11-06 00:00", tz=tz),
- pd.Timestamp("2011-01-01 00:00", tz=tz),
- pd.Timestamp("2012-01-01 00:00", tz=tz),
+ Timestamp("2016-11-06 00:00", tz=tz),
+ Timestamp("2011-01-01 00:00", tz=tz),
+ Timestamp("2012-01-01 00:00", tz=tz),
  ]
  )
  tm.assert_series_equal(s, exp)
@@ -568,7 +568,7 @@ def test_timedelta_assignment():
  s = Series(10 * [np.timedelta64(10, "m")])
  s.loc[[1, 2, 3]] = np.timedelta64(20, "m")
  expected = Series(10 * [np.timedelta64(10, "m")])
- expected.loc[[1, 2, 3]] = pd.Timedelta(np.timedelta64(20, "m"))
+ expected.loc[[1, 2, 3]] = Timedelta(np.timedelta64(20, "m"))
  tm.assert_series_equal(s, expected)
 
 
@@ -637,9 +637,9 @@ def test_td64_series_assign_nat(nat_val, should_cast):
 @pytest.mark.parametrize(
  "td",
  [
- pd.Timedelta("9 days"),
- pd.Timedelta("9 days").to_timedelta64(),
- pd.Timedelta("9 days").to_pytimedelta(),
+ Timedelta("9 days"),
+ Timedelta("9 days").to_timedelta64(),
+ Timedelta("9 days").to_pytimedelta(),
  ],
 )
 def test_append_timedelta_does_not_cast(td):
@@ -649,12 +649,12 @@ def test_append_timedelta_does_not_cast(td):
  ser = Series(["x"])
  ser["td"] = td
  tm.assert_series_equal(ser, expected)
- assert isinstance(ser["td"], pd.Timedelta)
+ assert isinstance(ser["td"], Timedelta)
 
  ser = Series(["x"])
- ser.loc["td"] = pd.Timedelta("9 days")
+ ser.loc["td"] = Timedelta("9 days")
  tm.assert_series_equal(ser, expected)
- assert isinstance(ser["td"], pd.Timedelta)
+ assert isinstance(ser["td"], Timedelta)
 
 
 def test_underlying_data_conversion():