API: return Index instead of array from datetime field accessors (GH15022)

Author: jorisvandenbossche

pandas/tests/indexes/datetimes/test_misc.py

@@ -313,5 +313,5 @@ def test_datetimeindex_accessors(self):
     def test_nanosecond_field(self):
         dti = DatetimeIndex(np.arange(10))
 
-        self.assert_numpy_array_equal(dti.nanosecond,
-                                      np.arange(10, dtype=np.int32))
+        self.assert_index_equal(dti.nanosecond,
+                                pd.Index(np.arange(10, dtype=np.int64)))

pandas/tests/indexes/period/test_construction.py

@@ -91,8 +91,8 @@ def test_constructor_arrays_negative_year(self):
 
         pindex = PeriodIndex(year=years, quarter=quarters)
 
-        self.assert_numpy_array_equal(pindex.year, years)
-        self.assert_numpy_array_equal(pindex.quarter, quarters)
+        self.assert_index_equal(pindex.year, pd.Index(years))
+        self.assert_index_equal(pindex.quarter, pd.Index(quarters))
 
     def test_constructor_invalid_quarters(self):
         self.assertRaises(ValueError, PeriodIndex, year=lrange(2000, 2004),

pandas/tests/indexes/period/test_period.py

@@ -660,10 +660,10 @@ def test_pindex_fieldaccessor_nat(self):
         idx = PeriodIndex(['2011-01', '2011-02', 'NaT',
                            '2012-03', '2012-04'], freq='D')
 
-        exp = np.array([2011, 2011, -1, 2012, 2012], dtype=np.int64)
-        self.assert_numpy_array_equal(idx.year, exp)
-        exp = np.array([1, 2, -1, 3, 4], dtype=np.int64)
-        self.assert_numpy_array_equal(idx.month, exp)
+        exp = Index([2011, 2011, -1, 2012, 2012], dtype=np.int64)
+        self.assert_index_equal(idx.year, exp)
+        exp = Index([1, 2, -1, 3, 4], dtype=np.int64)
+        self.assert_index_equal(idx.month, exp)
 
     def test_pindex_qaccess(self):
         pi = PeriodIndex(['2Q05', '3Q05', '4Q05', '1Q06', '2Q06'], freq='Q')

pandas/tests/tools/test_util.py

@@ -31,10 +31,10 @@ def test_datetimeindex(self):
         # make sure that the ordering on datetimeindex is consistent
         x = date_range('2000-01-01', periods=2)
         result1, result2 = [Index(y).day for y in cartesian_product([x, x])]
-        expected1 = np.array([1, 1, 2, 2], dtype=np.int32)
-        expected2 = np.array([1, 2, 1, 2], dtype=np.int32)
-        tm.assert_numpy_array_equal(result1, expected1)
-        tm.assert_numpy_array_equal(result2, expected2)
+        expected1 = Index([1, 1, 2, 2])
+        expected2 = Index([1, 2, 1, 2])
+        tm.assert_index_equal(result1, expected1)
+        tm.assert_index_equal(result2, expected2)
 
     def test_empty(self):
         # product of empty factors

pandas/tests/tseries/test_timezones.py

@@ -358,8 +358,8 @@ def test_field_access_localize(self):
         dr = date_range('2011-10-02 00:00', freq='h', periods=10,
                         tz=self.tzstr('America/Atikokan'))
 
-        expected = np.arange(10, dtype=np.int32)
-        self.assert_numpy_array_equal(dr.hour, expected)
+        expected = pd.Index(np.arange(10, dtype=np.int64))
+        self.assert_index_equal(dr.hour, expected)
 
     def test_with_tz(self):
         tz = self.tz('US/Central')
@@ -947,35 +947,35 @@ def test_tz_convert_hour_overflow_dst(self):
               '2009-05-12 09:50:32']
         tt = to_datetime(ts).tz_localize('US/Eastern')
         ut = tt.tz_convert('UTC')
-        expected = np.array([13, 14, 13], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([13, 14, 13])
+        self.assert_index_equal(ut.hour, expected)
 
         # sorted case UTC -> US/Eastern
         ts = ['2008-05-12 13:50:00',
               '2008-12-12 14:50:35',
               '2009-05-12 13:50:32']
         tt = to_datetime(ts).tz_localize('UTC')
         ut = tt.tz_convert('US/Eastern')
-        expected = np.array([9, 9, 9], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([9, 9, 9])
+        self.assert_index_equal(ut.hour, expected)
 
         # unsorted case US/Eastern -> UTC
         ts = ['2008-05-12 09:50:00',
               '2008-12-12 09:50:35',
               '2008-05-12 09:50:32']
         tt = to_datetime(ts).tz_localize('US/Eastern')
         ut = tt.tz_convert('UTC')
-        expected = np.array([13, 14, 13], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([13, 14, 13])
+        self.assert_index_equal(ut.hour, expected)
 
         # unsorted case UTC -> US/Eastern
         ts = ['2008-05-12 13:50:00',
               '2008-12-12 14:50:35',
               '2008-05-12 13:50:32']
         tt = to_datetime(ts).tz_localize('UTC')
         ut = tt.tz_convert('US/Eastern')
-        expected = np.array([9, 9, 9], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([9, 9, 9])
+        self.assert_index_equal(ut.hour, expected)
 
     def test_tz_convert_hour_overflow_dst_timestamps(self):
         # Regression test for:
@@ -989,35 +989,35 @@ def test_tz_convert_hour_overflow_dst_timestamps(self):
               Timestamp('2009-05-12 09:50:32', tz=tz)]
         tt = to_datetime(ts)
         ut = tt.tz_convert('UTC')
-        expected = np.array([13, 14, 13], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([13, 14, 13])
+        self.assert_index_equal(ut.hour, expected)
 
         # sorted case UTC -> US/Eastern
         ts = [Timestamp('2008-05-12 13:50:00', tz='UTC'),
               Timestamp('2008-12-12 14:50:35', tz='UTC'),
               Timestamp('2009-05-12 13:50:32', tz='UTC')]
         tt = to_datetime(ts)
         ut = tt.tz_convert('US/Eastern')
-        expected = np.array([9, 9, 9], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([9, 9, 9])
+        self.assert_index_equal(ut.hour, expected)
 
         # unsorted case US/Eastern -> UTC
         ts = [Timestamp('2008-05-12 09:50:00', tz=tz),
               Timestamp('2008-12-12 09:50:35', tz=tz),
               Timestamp('2008-05-12 09:50:32', tz=tz)]
         tt = to_datetime(ts)
         ut = tt.tz_convert('UTC')
-        expected = np.array([13, 14, 13], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([13, 14, 13])
+        self.assert_index_equal(ut.hour, expected)
 
         # unsorted case UTC -> US/Eastern
         ts = [Timestamp('2008-05-12 13:50:00', tz='UTC'),
               Timestamp('2008-12-12 14:50:35', tz='UTC'),
               Timestamp('2008-05-12 13:50:32', tz='UTC')]
         tt = to_datetime(ts)
         ut = tt.tz_convert('US/Eastern')
-        expected = np.array([9, 9, 9], dtype=np.int32)
-        self.assert_numpy_array_equal(ut.hour, expected)
+        expected = Index([9, 9, 9])
+        self.assert_index_equal(ut.hour, expected)
 
     def test_tslib_tz_convert_trans_pos_plus_1__bug(self):
         # Regression test for tslib.tz_convert(vals, tz1, tz2).
@@ -1028,9 +1028,8 @@ def test_tslib_tz_convert_trans_pos_plus_1__bug(self):
             idx = idx.tz_localize('UTC')
             idx = idx.tz_convert('Europe/Moscow')
 
-            expected = np.repeat(np.array([3, 4, 5], dtype=np.int32),
-                                 np.array([n, n, 1]))
-            self.assert_numpy_array_equal(idx.hour, expected)
+            expected = np.repeat(np.array([3, 4, 5]), np.array([n, n, 1]))
+            self.assert_index_equal(idx.hour, Index(expected))
 
     def test_tslib_tz_convert_dst(self):
         for freq, n in [('H', 1), ('T', 60), ('S', 3600)]:
@@ -1039,62 +1038,57 @@ def test_tslib_tz_convert_dst(self):
                              tz='UTC')
             idx = idx.tz_convert('US/Eastern')
             expected = np.repeat(np.array([18, 19, 20, 21, 22, 23,
-                                           0, 1, 3, 4, 5], dtype=np.int32),
+                                           0, 1, 3, 4, 5]),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
-            self.assert_numpy_array_equal(idx.hour, expected)
+            self.assert_index_equal(idx.hour, Index(expected))
 
             idx = date_range('2014-03-08 18:00', '2014-03-09 05:00', freq=freq,
                              tz='US/Eastern')
             idx = idx.tz_convert('UTC')
-            expected = np.repeat(np.array([23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
-                                          dtype=np.int32),
+            expected = np.repeat(np.array([23, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
-            self.assert_numpy_array_equal(idx.hour, expected)
+            self.assert_index_equal(idx.hour, Index(expected))
 
             # End DST
             idx = date_range('2014-11-01 23:00', '2014-11-02 09:00', freq=freq,
                              tz='UTC')
             idx = idx.tz_convert('US/Eastern')
             expected = np.repeat(np.array([19, 20, 21, 22, 23,
-                                           0, 1, 1, 2, 3, 4], dtype=np.int32),
+                                           0, 1, 1, 2, 3, 4]),
                                  np.array([n, n, n, n, n, n, n, n, n, n, 1]))
-            self.assert_numpy_array_equal(idx.hour, expected)
+            self.assert_index_equal(idx.hour, Index(expected))
 
             idx = date_range('2014-11-01 18:00', '2014-11-02 05:00', freq=freq,
                              tz='US/Eastern')
             idx = idx.tz_convert('UTC')
             expected = np.repeat(np.array([22, 23, 0, 1, 2, 3, 4, 5, 6,
-                                           7, 8, 9, 10], dtype=np.int32),
+                                           7, 8, 9, 10]),
                                  np.array([n, n, n, n, n, n, n, n, n,
                                            n, n, n, 1]))
-            self.assert_numpy_array_equal(idx.hour, expected)
+            self.assert_index_equal(idx.hour, Index(expected))
 
         # daily
         # Start DST
         idx = date_range('2014-03-08 00:00', '2014-03-09 00:00', freq='D',
                          tz='UTC')
         idx = idx.tz_convert('US/Eastern')
-        self.assert_numpy_array_equal(idx.hour,
-                                      np.array([19, 19], dtype=np.int32))
+        self.assert_index_equal(idx.hour, Index([19, 19]))
 
         idx = date_range('2014-03-08 00:00', '2014-03-09 00:00', freq='D',
                          tz='US/Eastern')
         idx = idx.tz_convert('UTC')
-        self.assert_numpy_array_equal(idx.hour,
-                                      np.array([5, 5], dtype=np.int32))
+        self.assert_index_equal(idx.hour, Index([5, 5]))
 
         # End DST
         idx = date_range('2014-11-01 00:00', '2014-11-02 00:00', freq='D',
                          tz='UTC')
         idx = idx.tz_convert('US/Eastern')
-        self.assert_numpy_array_equal(idx.hour,
-                                      np.array([20, 20], dtype=np.int32))
+        self.assert_index_equal(idx.hour, Index([20, 20]))
 
         idx = date_range('2014-11-01 00:00', '2014-11-02 000:00', freq='D',
                          tz='US/Eastern')
         idx = idx.tz_convert('UTC')
-        self.assert_numpy_array_equal(idx.hour,
-                                      np.array([4, 4], dtype=np.int32))
+        self.assert_index_equal(idx.hour, Index([4, 4]))
 
     def test_tzlocal(self):
         # GH 13583

pandas/tseries/common.py

@@ -105,6 +105,8 @@ def _delegate_property_get(self, name):
         elif not is_list_like(result):
             return result
 
+        result = np.asarray(result)
+
         # blow up if we operate on categories
         if self.orig is not None:
             result = take_1d(result, self.orig.cat.codes)

pandas/tseries/converter.py

@@ -455,7 +455,7 @@ def period_break(dates, period):
     """
     current = getattr(dates, period)
     previous = getattr(dates - 1, period)
-    return (current - previous).nonzero()[0]
+    return np.nonzero(current - previous)[0]
 
 
 def has_level_label(label_flags, vmin):

pandas/tseries/index.py

@@ -73,16 +73,19 @@ def f(self):
 
             result = libts.get_start_end_field(values, field, self.freqstr,
                                                month_kw)
+            result = self._maybe_mask_results(result, convert='float64')
+
         elif field in ['weekday_name']:
             result = libts.get_date_name_field(values, field)
-            return self._maybe_mask_results(result)
+            result = self._maybe_mask_results(result)
         elif field in ['is_leap_year']:
             # no need to mask NaT
-            return libts.get_date_field(values, field)
+            result = libts.get_date_field(values, field)
         else:
             result = libts.get_date_field(values, field)
+            result = self._maybe_mask_results(result, convert='float64')
 
-        return self._maybe_mask_results(result, convert='float64')
+        return Index(result)
 
     f.__name__ = name
     f.__doc__ = docstring
@@ -1909,9 +1912,9 @@ def to_julian_date(self):
         """
 
         # http://mysite.verizon.net/aesir_research/date/jdalg2.htm
-        year = self.year
-        month = self.month
-        day = self.day
+        year = np.asarray(self.year)
+        month = np.asarray(self.month)
+        day = np.asarray(self.day)
         testarr = month < 3
         year[testarr] -= 1
         month[testarr] += 12

pandas/tseries/period.py

@@ -52,7 +52,8 @@
 def _field_accessor(name, alias, docstring=None):
     def f(self):
         base, mult = _gfc(self.freq)
-        return get_period_field_arr(alias, self._values, base)
+        result = get_period_field_arr(alias, self._values, base)
+        return Index(result)
     f.__name__ = name
     f.__doc__ = docstring
     return property(f)
@@ -585,7 +586,7 @@ def to_datetime(self, dayfirst=False):
     @property
     def is_leap_year(self):
         """ Logical indicating if the date belongs to a leap year """
-        return tslib._isleapyear_arr(self.year)
+        return tslib._isleapyear_arr(np.asarray(self.year))
 
     @property
     def start_time(self):

pandas/tseries/util.py

@@ -54,7 +54,7 @@ def pivot_annual(series, freq=None):
 
     if freq == 'D':
         width = 366
-        offset = index.dayofyear - 1
+        offset = np.asarray(index.dayofyear) - 1
 
         # adjust for leap year
         offset[(~isleapyear(year)) & (offset >= 59)] += 1
@@ -63,7 +63,7 @@ def pivot_annual(series, freq=None):
         # todo: strings like 1/1, 1/25, etc.?
     elif freq in ('M', 'BM'):
         width = 12
-        offset = index.month - 1
+        offset = np.asarray(index.month) - 1
         columns = lrange(1, 13)
     elif freq == 'H':
         width = 8784