BUG: remove asserts from core #2288

Author: Chang She

pandas/core/format.py

@@ -293,8 +293,9 @@ def to_latex(self, force_unicode=False, column_format=None):
 
         if column_format is None:
             column_format = '|l|%s|' % '|'.join('c' for _ in strcols)
-        else:
-            assert isinstance(column_format, basestring)
+        elif not isinstance(column_format, basestring):
+            raise AssertionError(('column_format must be str or unicode, not %s'
+                                  % type(column_format)))
 
         self.buf.write('\\begin{tabular}{%s}\n' % column_format)
         self.buf.write('\\hline\n')
@@ -474,7 +475,9 @@ def write_result(self, buf):
         if self.classes is not None:
             if isinstance(self.classes, str):
                 self.classes = self.classes.split()
-            assert isinstance(self.classes, (list, tuple))
+            if not isinstance(self.classes, (list, tuple)):
+                raise AssertionError(('classes must be list or tuple, '
+                                      'not %s') % type(self.classes))
             _classes.extend(self.classes)
 
         self.write('<table border="1" class="%s">' % ' '.join(_classes),

pandas/core/frame.py

@@ -1138,8 +1138,9 @@ def to_panel(self):
         from pandas.core.reshape import block2d_to_block3d
 
         # only support this kind for now
-        assert(isinstance(self.index, MultiIndex) and
-               len(self.index.levels) == 2)
+        if (not isinstance(self.index, MultiIndex) or
+            len(self.index.levels) != 2):
+            raise AssertionError('Must have 2-level MultiIndex')
 
         self._consolidate_inplace()
 
@@ -1503,7 +1504,8 @@ def info(self, verbose=True, buf=None):
             lines.append('Data columns:')
             space = max([len(com.pprint_thing(k)) for k in self.columns]) + 4
             counts = self.count()
-            assert(len(cols) == len(counts))
+            if len(cols) != len(counts):
+                raise AssertionError('Columns must equal counts')
             for col, count in counts.iteritems():
                 if not isinstance(col, basestring):
                     col = str(col)
@@ -1962,7 +1964,8 @@ def _boolean_set(self, key, value):
 
     def _set_item_multiple(self, keys, value):
         if isinstance(value, DataFrame):
-            assert(len(value.columns) == len(keys))
+            if len(value.columns) != len(keys):
+                raise AssertionError('Columns must be same length as keys')
             for k1, k2 in zip(keys, value.columns):
                 self[k1] = value[k2]
         else:
@@ -2195,7 +2198,8 @@ def lookup(self, row_labels, col_labels):
         from itertools import izip
 
         n = len(row_labels)
-        assert(n == len(col_labels))
+        if n != len(col_labels):
+            raise AssertionError('Row labels must have same size as col labels')
 
         thresh = 1000
         if not self._is_mixed_type or n > thresh:
@@ -2973,7 +2977,8 @@ def sort_index(self, axis=0, by=None, ascending=True, inplace=False):
         labels = self._get_axis(axis)
 
         if by is not None:
-            assert(axis == 0)
+            if axis != 0:
+                raise AssertionError('Axis must be 0')
             if isinstance(by, (tuple, list)):
                 keys = [self[x].values for x in by]
                 indexer = _lexsort_indexer(keys, orders=ascending)
@@ -3934,7 +3939,8 @@ def _apply_raw(self, func, axis):
     def _apply_standard(self, func, axis, ignore_failures=False):
         try:
 
-            assert(not self._is_mixed_type)  # maybe a hack for now
+            if self._is_mixed_type:  # maybe a hack for now
+                raise AssertionError('Must be mixed type DataFrame')
             values = self.values
             dummy = Series(NA, index=self._get_axis(axis),
                            dtype=values.dtype)
@@ -4151,7 +4157,8 @@ def _join_compat(self, other, on=None, how='left', lsuffix='', rsuffix='',
         from pandas.tools.merge import merge, concat
 
         if isinstance(other, Series):
-            assert(other.name is not None)
+            if other.name is None:
+                raise AssertionError('Other Series must have a name')
             other = DataFrame({other.name: other})
 
         if isinstance(other, DataFrame):
@@ -5030,7 +5037,12 @@ def group_agg(values, bounds, f):
         result = np.empty((len(bounds), K), dtype=float)
 
     testagg = f(values[:min(1, len(values))])
-    assert(not (isinstance(testagg, np.ndarray) and testagg.ndim == 2))
+    if isinstance(testagg, np.ndarray):
+        raise AssertionError('Results must be an ndarray, not %s'
+                             % type(testagg))
+    if testagg.ndim == 2:
+        raise AssertionError('Results must be 2-D, not %d-D'
+                             % testagg.ndim)
 
     for i, left_bound in enumerate(bounds):
         if i == len(bounds) - 1:

pandas/core/generic.py

@@ -340,15 +340,17 @@ def drop(self, labels, axis=0, level=None):
 
         if axis.is_unique:
             if level is not None:
-                assert(isinstance(axis, MultiIndex))
+                if not isinstance(axis, MultiIndex):
+                    raise AssertionError('axis must be a MultiIndex')
                 new_axis = axis.drop(labels, level=level)
             else:
                 new_axis = axis.drop(labels)
 
             return self.reindex(**{axis_name: new_axis})
         else:
             if level is not None:
-                assert(isinstance(axis, MultiIndex))
+                if not isinstance(axis, MultiIndex):
+                    raise AssertionError('axis must be a MultiIndex')
                 indexer = -lib.ismember(axis.get_level_values(level),
                                         set(labels))
             else:
@@ -1012,7 +1014,9 @@ def truncate(self, before=None, after=None, copy=True):
     after = to_datetime(after)
 
     if before is not None and after is not None:
-        assert(before <= after)
+        if before > after:
+            raise AssertionError('Truncate: %s must be after %s' %
+                                 (before, after))
 
     result = self.ix[before:after]
 

pandas/core/groupby.py

@@ -830,12 +830,9 @@ def _aggregate_series_pure_python(self, obj, func):
                                              axis=self.axis):
             res = func(group)
             if result is None:
-                try:
-                    assert(not isinstance(res, np.ndarray))
-                    assert(not isinstance(res, list))
-                    result = np.empty(ngroups, dtype='O')
-                except Exception:
-                    raise ValueError('function does not reduce')
+                if isinstance(res, np.ndarray) or isinstance(res, list):
+                    raise ValueError('Function does not reduce')
+                result = np.empty(ngroups, dtype='O')
 
             counts[label] = group.shape[0]
             result[label] = res
@@ -1040,7 +1037,8 @@ def __init__(self, index, grouper=None, name=None, level=None,
 
         if level is not None:
             if not isinstance(level, int):
-                assert(level in index.names)
+                if level not in index.names:
+                    raise AssertionError('Level %s not in index' % str(level))
                 level = index.names.index(level)
 
             inds = index.labels[level]
@@ -1231,7 +1229,8 @@ def _convert_grouper(axis, grouper):
         else:
             return grouper.reindex(axis).values
     elif isinstance(grouper, (list, np.ndarray)):
-        assert(len(grouper) == len(axis))
+        if len(grouper) != len(axis):
+            raise AssertionError('Grouper and axis must be same length')
         return grouper
     else:
         return grouper
@@ -1629,7 +1628,8 @@ def _aggregate_multiple_funcs(self, arg):
         return result
 
     def _aggregate_generic(self, func, *args, **kwargs):
-        assert(self.grouper.nkeys == 1)
+        if self.grouper.nkeys != 1:
+            raise AssertionError('Number of keys must be 1')
 
         axis = self.axis
         obj = self._obj_with_exclusions
@@ -2061,7 +2061,9 @@ def _get_slice(slob):
         # Since I'm now compressing the group ids, it's now not "possible" to
         # produce empty slices because such groups would not be observed in the
         # data
-        assert(start < end)
+        if start >= end:
+            raise AssertionError('Start %s must be less than end %s'
+                                 % (str(start), str(end)))
         yield i, _get_slice(slice(start, end))
 
 

pandas/core/index.py

@@ -180,7 +180,9 @@ def _get_names(self):
         return [self.name]
 
     def _set_names(self, values):
-        assert(len(values) == 1)
+        if len(values) != 1:
+            raise AssertionError('Length of new names must be 1, got %d'
+                                 % len(values))
         self.name = values[0]
 
     names = property(fset=_set_names, fget=_get_names)
@@ -255,7 +257,9 @@ def _engine(self):
 
     def _get_level_number(self, level):
         if not isinstance(level, int):
-            assert(level == self.name)
+            if level != self.name:
+                raise AssertionError('Level %s must be same as name (%s)'
+                                     % (level, self.name))
             level = 0
         return level
 
@@ -749,10 +753,12 @@ def get_indexer(self, target, method=None, limit=None):
                             'objects')
 
         if method == 'pad':
-            assert(self.is_monotonic)
+            if not self.is_monotonic:
+                raise AssertionError('Must be monotonic for forward fill')
             indexer = self._engine.get_pad_indexer(target.values, limit)
         elif method == 'backfill':
-            assert(self.is_monotonic)
+            if not self.is_monotonic:
+                raise AssertionError('Must be monotonic for backward fill')
             indexer = self._engine.get_backfill_indexer(target.values, limit)
         elif method is None:
             indexer = self._engine.get_indexer(target.values)
@@ -1249,7 +1255,8 @@ class MultiIndex(Index):
     names = None
 
     def __new__(cls, levels=None, labels=None, sortorder=None, names=None):
-        assert(len(levels) == len(labels))
+        if len(levels) != len(labels):
+            raise AssertionError('Length of levels and labels must be the same')
         if len(levels) == 0:
             raise Exception('Must pass non-zero number of levels/labels')
 
@@ -1272,7 +1279,10 @@ def __new__(cls, levels=None, labels=None, sortorder=None, names=None):
         if names is None:
             subarr.names = [None] * subarr.nlevels
         else:
-            assert(len(names) == subarr.nlevels)
+            if len(names) != subarr.nlevels:
+                raise AssertionError(('Length of names must be same as level '
+                                      '(%d), got %d') % (subarr.nlevels))
+
             subarr.names = list(names)
 
         # set the name
@@ -1815,7 +1825,10 @@ def reorder_levels(self, order):
         ----------
         """
         order = [self._get_level_number(i) for i in order]
-        assert(len(order) == self.nlevels)
+        if len(order) != self.nlevels:
+            raise AssertionError(('Length of order must be same as '
+                                  'number of levels (%d), got %d')
+                                 % (self.nlevels, len(order)))
         new_levels = [self.levels[i] for i in order]
         new_labels = [self.labels[i] for i in order]
         new_names = [self.names[i] for i in order]
@@ -1912,11 +1925,15 @@ def get_indexer(self, target, method=None, limit=None):
         self_index = self._tuple_index
 
         if method == 'pad':
-            assert(self.is_unique and self.is_monotonic)
+            if not self.is_unique or not self.is_monotonic:
+                raise AssertionError(('Must be unique and monotonic to '
+                                      'use forward fill getting the indexer'))
             indexer = self_index._engine.get_pad_indexer(target_index,
                                                          limit=limit)
         elif method == 'backfill':
-            assert(self.is_unique and self.is_monotonic)
+            if not self.is_unique or not self.is_monotonic:
+                raise AssertionError(('Must be unique and monotonic to '
+                                      'use backward fill getting the indexer'))
             indexer = self_index._engine.get_backfill_indexer(target_index,
                                                               limit=limit)
         else:
@@ -2083,7 +2100,9 @@ def _drop_levels(indexer, levels):
             return new_index
 
         if isinstance(level, (tuple, list)):
-            assert(len(key) == len(level))
+            if len(key) != len(level):
+                raise AssertionError('Key for location must have same '
+                                     'length as number of levels')
             result = None
             for lev, k in zip(level, key):
                 loc, new_index = self.get_loc_level(k, level=lev)
@@ -2329,7 +2348,8 @@ def _assert_can_do_setop(self, other):
             raise TypeError('can only call with other hierarchical '
                             'index objects')
 
-        assert(self.nlevels == other.nlevels)
+        if self.nlevels != other.nlevels:
+            raise AssertionError('Must have same number of levels')
 
     def insert(self, loc, item):
         """
@@ -2477,7 +2497,8 @@ def _get_distinct_indexes(indexes):
 
 
 def _union_indexes(indexes):
-    assert(len(indexes) > 0)
+    if len(indexes) == 0:
+        raise AssertionError('Must have at least 1 Index to union')
     if len(indexes) == 1:
         result = indexes[0]
         if isinstance(result, list):

pandas/core/indexing.py

@@ -358,7 +358,8 @@ def _reindex(keys, level=None):
                 return self.obj.reindex_axis(keys, axis=axis, level=level)
             except AttributeError:
                 # Series
-                assert(axis == 0)
+                if axis != 0:
+                    raise AssertionError('axis must be 0')
                 return self.obj.reindex(keys, level=level)
 
         if com._is_bool_indexer(key):