move tests to generically tests for index

generify __unicode__ for Index

Author: jreback

pandas/core/index.py

@@ -392,15 +392,35 @@ def __unicode__(self):
         Invoked by unicode(df) in py2 only. Yields a Unicode String in both
         py2/py3.
         """
-        prepr = com.pprint_thing(self, escape_chars=('\t', '\r', '\n'),
-                                 quote_strings=True)
+        klass = self.__class__.__name__
+        space = ' ' * (len(klass) + 1)
+        data = self._format_data()
+        attrs = self._format_attrs()
+        prepr = (u(",\n%s") % space).join([u("%s=%s") % (k, v)
+                                          for k, v in attrs])
+        res = u("%s(%s,\n%s%s)") % (klass,
+                                    data,
+                                    space,
+                                    prepr)
+
+        return res
 
-        name_attr=''
-        if self.name:
-            name_attr = u(" %s=%s,") % ('name', self.name)
+    def _format_data(self):
+        """
+        Return the formatted data as a unicode string
+        """
+        return com.pprint_thing(self, escape_chars=('\t', '\r', '\n'),
+                                quote_strings=True)
 
-        return "%s(%s,%s dtype='%s')" % (type(self).__name__,
-                prepr, name_attr, self.dtype)
+    def _format_attrs(self):
+        """
+        Return a list of tuples of the (attr,formatted_value)
+        """
+        attrs = []
+        if self.name is not None:
+            attrs.append(('name',default_pprint(self.name)))
+        attrs.append(('dtype',"'%s'" % self.dtype))
+        return attrs
 
     def to_series(self, **kwargs):
         """

pandas/tests/test_index.py

@@ -120,6 +120,19 @@ def test_ndarray_compat_properties(self):
         idx.nbytes
         idx.values.nbytes
 
+    def test_repr_roundtrip(self):
+
+        idx = self.create_index()
+        tm.assert_index_equal(eval(repr(idx)),idx)
+
+    def test_str(self):
+
+        # test the string repr
+        idx = self.create_index()
+        idx.name = 'foo'
+        self.assertTrue("'foo'" in str(idx))
+        self.assertTrue(idx.__class__.__name__ in str(idx))
+
     def test_wrong_number_names(self):
         def testit(ind):
             ind.names = ["apple", "banana", "carrot"]
@@ -2467,6 +2480,26 @@ def test_slice_keep_name(self):
 
 class DatetimeLike(Base):
 
+    def test_repr_roundtrip(self):
+        raise nose.SkipTest("Short reprs are not supported repr for Datetimelike indexes")
+
+    def test_str(self):
+
+        # test the string repr
+        idx = self.create_index()
+        idx.name = 'foo'
+        self.assertTrue("length=%s" % len(idx) in str(idx))
+        self.assertTrue("u'foo'" in str(idx))
+        self.assertTrue(idx.__class__.__name__ in str(idx))
+
+        if hasattr(idx,'tz'):
+            if idx.tz is not None:
+                self.assertTrue("tz='%s'" % idx.tz in str(idx))
+            else:
+                self.assertTrue("tz=None" in str(idx))
+        if hasattr(idx,'freq'):
+            self.assertTrue("freq='%s'" % idx.freqstr in str(idx))
+
     def test_view(self):
         super(DatetimeLike, self).test_view()
 
@@ -4380,8 +4413,9 @@ def test_repr_with_unicode_data(self):
             index = pd.DataFrame(d).set_index(["a", "b"]).index
             self.assertFalse("\\u" in repr(index))  # we don't want unicode-escaped
 
-    def test_repr_roundtrip(self):
-        tm.assert_index_equal(eval(repr(self.index)), self.index)
+    def test_str(self):
+        # tested elsewhere
+        pass
 
     def test_unicode_string_with_unicode(self):
         d = {"a": [u("\u05d0"), 2, 3], "b": [4, 5, 6], "c": [7, 8, 9]}

pandas/tseries/base.py

@@ -260,31 +260,48 @@ def _formatter_func(self):
         """
         return str
 
-    def _format_footer(self):
-        raise AbstractMethodError(self)
+    def _format_data(self):
+        """
+        Return the formatted data as a unicode string
+        """
 
-    def __unicode__(self):
         formatter = self._formatter_func
-        summary = str(self.__class__) + '\n'
-
         n = len(self)
         if n == 0:
-            pass
+            summary = '[]'
         elif n == 1:
             first = formatter(self[0])
-            summary += '[%s]\n' % first
+            summary = '[%s]' % first
         elif n == 2:
             first = formatter(self[0])
             last = formatter(self[-1])
-            summary += '[%s, %s]\n' % (first, last)
+            summary = '[%s, %s]' % (first, last)
         else:
             first = formatter(self[0])
             last = formatter(self[-1])
-            summary += '[%s, ..., %s]\n' % (first, last)
+            summary = '[%s, ..., %s]' % (first, last)
 
-        summary += self._format_footer()
         return summary
 
+    def _format_attrs(self):
+        """
+        Return a list of tuples of the (attr,formatted_value)
+        """
+        attrs = super(DatetimeIndexOpsMixin, self)._format_attrs()
+        attrs.append(('length',len(self)))
+        for attrib in self._attributes:
+            if attrib == 'freq':
+                freq = self.freqstr
+                if freq is not None:
+                    freq = "'%s'" % freq
+                attrs.append(('freq',freq))
+            elif attrib == 'tz':
+                tz = self.tz
+                if tz is not None:
+                    tz = "'%s'" % tz
+                attrs.append(('tz',tz))
+        return attrs
+
     @cache_readonly
     def _resolution(self):
         from pandas.tseries.frequencies import Resolution

pandas/tseries/index.py

@@ -684,10 +684,6 @@ def _format_native_types(self, na_rep=u('NaT'),
     def to_datetime(self, dayfirst=False):
         return self.copy()
 
-    def _format_footer(self):
-        tagline = 'Length: %d, Freq: %s, Timezone: %s'
-        return tagline % (len(self), self.freqstr, self.tz)
-
     def astype(self, dtype):
         dtype = np.dtype(dtype)
 

pandas/tseries/period.py

@@ -697,10 +697,6 @@ def __array_finalize__(self, obj):
         self.name = getattr(obj, 'name', None)
         self._reset_identity()
 
-    def _format_footer(self):
-        tagline = 'Length: %d, Freq: %s'
-        return tagline % (len(self), self.freqstr)
-
     def take(self, indices, axis=None):
         """
         Analogous to ndarray.take

pandas/tseries/tdi.py

@@ -274,10 +274,6 @@ def _formatter_func(self):
         from pandas.core.format import _get_format_timedelta64
         return _get_format_timedelta64(self, box=True)
 
-    def _format_footer(self):
-        tagline = 'Length: %d, Freq: %s'
-        return tagline % (len(self), self.freqstr)
-
     def __setstate__(self, state):
         """Necessary for making this object picklable"""
         if isinstance(state, dict):

pandas/tseries/tests/test_base.py

@@ -119,23 +119,41 @@ def test_representation(self):
         idx6 = DatetimeIndex(['2011-01-01 09:00', '2011-01-01 10:00', pd.NaT],
                              tz='US/Eastern')
 
-        exp1 = """<class 'pandas.tseries.index.DatetimeIndex'>
-Length: 0, Freq: D, Timezone: None"""
-        exp2 = """<class 'pandas.tseries.index.DatetimeIndex'>
-[2011-01-01]
-Length: 1, Freq: D, Timezone: None"""
-        exp3 = """<class 'pandas.tseries.index.DatetimeIndex'>
-[2011-01-01, 2011-01-02]
-Length: 2, Freq: D, Timezone: None"""
-        exp4 = """<class 'pandas.tseries.index.DatetimeIndex'>
-[2011-01-01, ..., 2011-01-03]
-Length: 3, Freq: D, Timezone: None"""
-        exp5 = """<class 'pandas.tseries.index.DatetimeIndex'>
-[2011-01-01 09:00:00+09:00, ..., 2011-01-01 11:00:00+09:00]
-Length: 3, Freq: H, Timezone: Asia/Tokyo"""
-        exp6 = """<class 'pandas.tseries.index.DatetimeIndex'>
-[2011-01-01 09:00:00-05:00, ..., NaT]
-Length: 3, Freq: None, Timezone: US/Eastern"""
+        exp1 = """DatetimeIndex([],
+              dtype='datetime64[ns]',
+              length=0,
+              freq='D',
+              tz=None)"""
+
+        exp2 = """DatetimeIndex([2011-01-01],
+              dtype='datetime64[ns]',
+              length=1,
+              freq='D',
+              tz=None)"""
+
+        exp3 = """DatetimeIndex([2011-01-01, 2011-01-02],
+              dtype='datetime64[ns]',
+              length=2,
+              freq='D',
+              tz=None)"""
+
+        exp4 = """DatetimeIndex([2011-01-01, ..., 2011-01-03],
+              dtype='datetime64[ns]',
+              length=3,
+              freq='D',
+              tz=None)"""
+
+        exp5 = """DatetimeIndex([2011-01-01 09:00:00+09:00, ..., 2011-01-01 11:00:00+09:00],
+              dtype='datetime64[ns]',
+              length=3,
+              freq='H',
+              tz='Asia/Tokyo')"""
+
+        exp6 = """DatetimeIndex([2011-01-01 09:00:00-05:00, ..., NaT],
+              dtype='datetime64[ns]',
+              length=3,
+              freq=None,
+              tz='US/Eastern')"""
 
         for idx, expected in zip([idx1, idx2, idx3, idx4, idx5, idx6],
                                  [exp1, exp2, exp3, exp4, exp5, exp6]):
@@ -372,21 +390,30 @@ def test_representation(self):
         idx4 = TimedeltaIndex(['1 days', '2 days', '3 days'], freq='D')
         idx5 = TimedeltaIndex(['1 days 00:00:01', '2 days', '3 days'])
 
+        exp1 = """TimedeltaIndex([],
+               dtype='timedelta64[ns]',
+               length=0,
+               freq='D')"""
 
-        exp1 = """<class 'pandas.tseries.tdi.TimedeltaIndex'>
-Length: 0, Freq: D"""
-        exp2 = """<class 'pandas.tseries.tdi.TimedeltaIndex'>
-['1 days']
-Length: 1, Freq: D"""
-        exp3 = """<class 'pandas.tseries.tdi.TimedeltaIndex'>
-['1 days', '2 days']
-Length: 2, Freq: D"""
-        exp4 = """<class 'pandas.tseries.tdi.TimedeltaIndex'>
-['1 days', ..., '3 days']
-Length: 3, Freq: D"""
-        exp5 = """<class 'pandas.tseries.tdi.TimedeltaIndex'>
-['1 days 00:00:01', ..., '3 days 00:00:00']
-Length: 3, Freq: None"""
+        exp2 = """TimedeltaIndex(['1 days'],
+               dtype='timedelta64[ns]',
+               length=1,
+               freq='D')"""
+
+        exp3 = """TimedeltaIndex(['1 days', '2 days'],
+               dtype='timedelta64[ns]',
+               length=2,
+               freq='D')"""
+
+        exp4 = """TimedeltaIndex(['1 days', ..., '3 days'],
+               dtype='timedelta64[ns]',
+               length=3,
+               freq='D')"""
+
+        exp5 = """TimedeltaIndex(['1 days 00:00:01', ..., '3 days 00:00:00'],
+               dtype='timedelta64[ns]',
+               length=3,
+               freq=None)"""
 
         for idx, expected in zip([idx1, idx2, idx3, idx4, idx5],
                                  [exp1, exp2, exp3, exp4, exp5]):
@@ -842,32 +869,50 @@ def test_representation(self):
         idx8 = pd.period_range('2013Q1', periods=2, freq="Q")
         idx9 = pd.period_range('2013Q1', periods=3, freq="Q")
 
-        exp1 = """<class 'pandas.tseries.period.PeriodIndex'>
-Length: 0, Freq: D"""
-        exp2 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2011-01-01]
-Length: 1, Freq: D"""
-        exp3 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2011-01-01, 2011-01-02]
-Length: 2, Freq: D"""
-        exp4 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2011-01-01, ..., 2011-01-03]
-Length: 3, Freq: D"""
-        exp5 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2011, ..., 2013]
-Length: 3, Freq: A-DEC"""
-        exp6 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2011-01-01 09:00, ..., NaT]
-Length: 3, Freq: H"""
-        exp7 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2013Q1]
-Length: 1, Freq: Q-DEC"""
-        exp8 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2013Q1, 2013Q2]
-Length: 2, Freq: Q-DEC"""
-        exp9 = """<class 'pandas.tseries.period.PeriodIndex'>
-[2013Q1, ..., 2013Q3]
-Length: 3, Freq: Q-DEC"""
+        exp1 = """PeriodIndex([],
+            dtype='int64',
+            length=0,
+            freq='D')"""
+
+        exp2 = """PeriodIndex([2011-01-01],
+            dtype='int64',
+            length=1,
+            freq='D')"""
+
+        exp3 = """PeriodIndex([2011-01-01, 2011-01-02],
+            dtype='int64',
+            length=2,
+            freq='D')"""
+
+        exp4 = """PeriodIndex([2011-01-01, ..., 2011-01-03],
+            dtype='int64',
+            length=3,
+            freq='D')"""
+
+        exp5 = """PeriodIndex([2011, ..., 2013],
+            dtype='int64',
+            length=3,
+            freq='A-DEC')"""
+
+        exp6 = """PeriodIndex([2011-01-01 09:00, ..., NaT],
+            dtype='int64',
+            length=3,
+            freq='H')"""
+
+        exp7 = """PeriodIndex([2013Q1],
+            dtype='int64',
+            length=1,
+            freq='Q-DEC')"""
+
+        exp8 = """PeriodIndex([2013Q1, 2013Q2],
+            dtype='int64',
+            length=2,
+            freq='Q-DEC')"""
+
+        exp9 = """PeriodIndex([2013Q1, ..., 2013Q3],
+            dtype='int64',
+            length=3,
+            freq='Q-DEC')"""
 
         for idx, expected in zip([idx1, idx2, idx3, idx4, idx5, idx6, idx7, idx8, idx9],
                                  [exp1, exp2, exp3, exp4, exp5, exp6, exp7, exp8, exp9]):

pandas/util/testing.py

@@ -1627,7 +1627,7 @@ class _AssertRaisesContextmanager(object):
     def __init__(self, exception, regexp=None, *args, **kwargs):
         self.exception = exception
         if regexp is not None and not hasattr(regexp, "search"):
-            regexp = re.compile(regexp)
+            regexp = re.compile(regexp, re.DOTALL)
         self.regexp = regexp
 
     def __enter__(self):