API/BUG: Handling Dtype Coercions in Series/Index (GH 15832)

pandas/core/dtypes/cast.py

@@ -16,6 +16,7 @@
                      is_timedelta64_dtype, is_dtype_equal,
                      is_float_dtype, is_complex_dtype,
                      is_integer_dtype,
+                     is_unsigned_integer_dtype,
                      is_datetime_or_timedelta_dtype,
                      is_bool_dtype, is_scalar,
                      _string_dtypes,
@@ -1026,3 +1027,37 @@ def find_common_type(types):
             return np.object
 
     return np.find_common_type(types, [])
+
+
+def maybe_cast_to_integer(arr, dtype):
+    """
+    Takes an integer dtype and returns the casted version, raising for an
+    incompatible dtype.
+
+    Parameters
+    ----------
+    arr : ndarray
+    dtype : np.dtype
+
+    Returns
+    -------
+    integer or unsigned integer array
+
+    Raises
+    ------
+    OverflowError
+        * If ``dtype`` is incompatible
+    ValueError
+        * If coercion from float to integer loses precision
+
+    """
+
+    if is_unsigned_integer_dtype(dtype) and (arr < 0).any():
+        raise OverflowError("Trying to coerce negative values to negative "
+                            "integers")
+    elif is_integer_dtype(dtype) and (is_float_dtype(arr) or
+                                      is_object_dtype(arr)):
+        if not (arr == arr.astype(dtype)).all():
+            raise ValueError("Trying to coerce float values to integers")
+
+    return arr.astype(dtype, copy=False)

pandas/core/indexes/base.py

@@ -15,6 +15,7 @@
 
 from pandas.core.dtypes.generic import ABCSeries, ABCMultiIndex, ABCPeriodIndex
 from pandas.core.dtypes.missing import isnull, array_equivalent
+from pandas.core.dtypes.cast import maybe_cast_to_integer
 from pandas.core.dtypes.common import (
     _ensure_int64,
     _ensure_object,
@@ -212,11 +213,14 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
                     if is_integer_dtype(dtype):
                         inferred = lib.infer_dtype(data)
                         if inferred == 'integer':
+                            data = maybe_cast_to_integer(data, dtype=dtype)
                             data = np.array(data, copy=copy, dtype=dtype)
                         elif inferred in ['floating', 'mixed-integer-float']:
                             if isnull(data).any():
                                 raise ValueError('cannot convert float '
                                                  'NaN to integer')
+                            if inferred == 'mixed-integer-float':
+                                maybe_cast_to_integer(data, dtype)
 
                             # If we are actually all equal to integers,
                             # then coerce to integer.
@@ -248,6 +252,8 @@ def __new__(cls, data=None, dtype=None, copy=False, name=None,
                     msg = str(e)
                     if 'cannot convert float' in msg:
                         raise
+                    if 'Trying to coerce float values to integer' in msg:
+                        raise
 
             # maybe coerce to a sub-class
             from pandas.core.indexes.period import (

pandas/core/series.py

@@ -35,7 +35,8 @@
 from pandas.core.dtypes.cast import (
     maybe_upcast, infer_dtype_from_scalar,
     maybe_convert_platform,
-    maybe_cast_to_datetime, maybe_castable)
+    maybe_cast_to_datetime, maybe_castable,
+    maybe_cast_to_integer)
 from pandas.core.dtypes.missing import isnull, notnull
 
 from pandas.core.common import (is_bool_indexer,
@@ -2916,9 +2917,13 @@ def _try_cast(arr, take_fast_path):
                 return arr
 
         try:
+            if is_float_dtype(dtype) or is_integer_dtype(dtype):
+                subarr = maybe_cast_to_integer(np.asarray(arr), dtype)
+
             subarr = maybe_cast_to_datetime(arr, dtype)
             if not is_extension_type(subarr):
                 subarr = np.array(subarr, dtype=dtype, copy=copy)
+
         except (ValueError, TypeError):
             if is_categorical_dtype(dtype):
                 subarr = Categorical(arr)

pandas/tests/indexes/test_numeric.py

@@ -304,6 +304,18 @@ def test_astype(self):
             i = Float64Index([0, 1.1, np.NAN])
             pytest.raises(ValueError, lambda: i.astype(dtype))
 
+        # GH 15832
+        for t in ['uint8', 'uint16', 'uint32', 'uint64', 'int32', 'int64',
+                  'int16', 'int8']:
+            with pytest.raises(ValueError):
+                Index([1, 2, 3.5], dtype=t)
+
+        try:
+            for t in ['float16', 'float32']:
+                Index([1, 2, 3.5], dtype=t)
+        except ValueError:
+            pytest.fail("GH 15832 should not raise for float type")
+
     def test_equals_numeric(self):
 
         i = Float64Index([1.0, 2.0])
@@ -678,6 +690,12 @@ def test_constructor_corner(self):
         with tm.assert_raises_regex(TypeError, 'casting'):
             Int64Index(arr_with_floats)
 
+    def test_constructor_overflow_coercion_signed_to_unsigned(self):
+        # GH 15832
+        for t in ['uint8', 'uint16', 'uint32', 'uint64']:
+            with pytest.raises(OverflowError):
+                Index([-1], dtype=t)
+
     def test_coerce_list(self):
         # coerce things
         arr = Index([1, 2, 3, 4])

pandas/tests/io/test_pytables.py

@@ -2080,7 +2080,7 @@ def test_table_values_dtypes_roundtrip(self):
             assert df1.dtypes[0] == 'float32'
 
             # check with mixed dtypes
-            df1 = DataFrame(dict([(c, Series(np.random.randn(5), dtype=c))
+            df1 = DataFrame(dict([(c, Series(np.random.randn(5).astype(c)))
                                   for c in ['float32', 'float64', 'int32',
                                             'int64', 'int16', 'int8']]))
             df1['string'] = 'foo'
@@ -2094,7 +2094,8 @@ def test_table_values_dtypes_roundtrip(self):
             result = store.select('df_mixed_dtypes1').get_dtype_counts()
             expected = Series({'float32': 2, 'float64': 1, 'int32': 1,
                                'bool': 1, 'int16': 1, 'int8': 1,
-                               'int64': 1, 'object': 1, 'datetime64[ns]': 2})
+                               'int64': 1, 'object': 1,
+                               'datetime64[ns]': 2})
             result = result.sort_index()
             result = expected.sort_index()
             tm.assert_series_equal(result, expected)

pandas/tests/series/test_constructors.py

@@ -1,30 +1,26 @@
 # coding=utf-8
 # pylint: disable-msg=E1101,W0612
 
-import pytest
-
 from datetime import datetime, timedelta
 
-from numpy import nan
 import numpy as np
 import numpy.ma as ma
 import pandas as pd
-
-from pandas.core.dtypes.common import (
-    is_categorical_dtype,
-    is_datetime64tz_dtype)
+import pytest
+from numpy import nan
 from pandas import (Index, Series, isnull, date_range,
                     NaT, period_range, MultiIndex, IntervalIndex)
-from pandas.core.indexes.datetimes import Timestamp, DatetimeIndex
+from pandas import compat
+from pandas.compat import lrange, range, zip, OrderedDict, long
 
+import pandas.util.testing as tm
 from pandas._libs import lib
 from pandas._libs.tslib import iNaT
-
-from pandas.compat import lrange, range, zip, OrderedDict, long
-from pandas import compat
+from pandas.core.dtypes.common import (
+    is_categorical_dtype,
+    is_datetime64tz_dtype)
+from pandas.core.indexes.datetimes import Timestamp, DatetimeIndex
 from pandas.util.testing import assert_series_equal
-import pandas.util.testing as tm
-
 from .common import TestData
 
 
@@ -303,9 +299,27 @@ def test_constructor_pass_nan_nat(self):
     def test_constructor_cast(self):
         pytest.raises(ValueError, Series, ['a', 'b', 'c'], dtype=float)
 
+        # GH 15832
+        for t in ['uint8', 'uint16', 'uint32', 'uint64']:
+            with pytest.raises(OverflowError):
+                Series([-1], dtype=t)
+
+        # GH 15832
+        for t in ['uint8', 'uint16', 'uint32', 'uint64', 'int32', 'int64',
+                  'int16', 'int8']:
+            with pytest.raises(ValueError):
+                Series([1, 2, 3.5], dtype=t)
+
+        try:
+            for t in ['float16', 'float32']:
+                Series([1, 2, 3.5], dtype=t)
+        except ValueError:
+            pytest.fail("GH 15832 should not raise for float type")
+
     def test_constructor_dtype_nocast(self):
         # 1572
         s = Series([1, 2, 3])
+        s = Series([1, 2, 3])
 
         s2 = Series(s, dtype=np.int64)