Pre-migration to Numba 0.50 (#887)

Author: kozlov-alexey

sdc/datatypes/hpat_pandas_series_functions.py

@@ -4887,7 +4887,7 @@ def sdc_pandas_series_skew(self, axis=None, skipna=None, level=None, numeric_onl
         .. only:: developer
             Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_skew*
         """
-    _func_name = 'Method Series.skew()'
+    _func_name = 'Method Series.skew().'
 
     ty_checker = TypeChecker(_func_name)
     ty_checker.check(self, SeriesType)

sdc/extensions/indexes/range_index_ext.py

@@ -97,6 +97,7 @@ def pd_range_index_overload(start=None, stop=None, step=None, dtype=None, copy=F
         raise SDCLimitation(f"{_func_name} Unsupported parameter. Given 'fastpath': {fastpath}")
 
     dtype_is_np_int64 = dtype is types.NumberClass(types.int64)
+    dtype_is_unicode_str = isinstance(dtype, (types.UnicodeType, types.StringLiteral))
     if not _check_dtype_param_type(dtype):
         ty_checker.raise_exc(dtype, 'int64 dtype', 'dtype')
 
@@ -119,10 +120,11 @@ def pd_range_index_ctor_dummy_impl(
             raise TypeError("RangeIndex(...) must be called with integers")
 
         return pd_range_index_ctor_dummy_impl
+
     def pd_range_index_ctor_impl(start=None, stop=None, step=None, dtype=None, copy=False, name=None, fastpath=None):
 
         if not (dtype is None
-                or dtype == 'int64'
+                or dtype_is_unicode_str and dtype == 'int64'
                 or dtype_is_np_int64):
             raise TypeError("Invalid to pass a non-int64 dtype to RangeIndex")
 
@@ -154,9 +156,9 @@ def box_range_index(typ, val, c):
     mod_name = c.context.insert_const_string(c.builder.module, "pandas")
     pd_class_obj = c.pyapi.import_module_noblock(mod_name)
 
-    range_index = numba.core.cgutils.create_struct_proxy(
+    range_index = cgutils.create_struct_proxy(
         typ)(c.context, c.builder, val)
-    range_index_data = numba.core.cgutils.create_struct_proxy(
+    range_index_data = cgutils.create_struct_proxy(
         RangeIndexDataType)(c.context, c.builder, range_index.data)
 
     start = c.pyapi.from_native_value(types.int64, range_index_data.start)
@@ -168,6 +170,7 @@ def box_range_index(typ, val, c):
     copy = c.pyapi.bool_from_bool(
         c.context.get_constant(types.bool_, False)
     )
+
     if typ.is_named:
         name = c.pyapi.from_native_value(types.unicode_type, range_index.name)
     else:
@@ -266,6 +269,7 @@ def pd_range_index_dtype_overload(self):
         return None
 
     range_index_dtype = self.dtype
+
     def pd_range_index_dtype_impl(self):
         return range_index_dtype
 

sdc/functions/numpy_like.py

@@ -124,7 +124,7 @@ def sdc_astype_overload(self, dtype):
 
     if not isinstance(dtype, (types.functions.NumberClass, types.Function, types.Literal)):
         def impl(self, dtype):
-            return astype(self, literally(dtype))
+            return literally(dtype)
 
         return impl
 
@@ -900,11 +900,14 @@ def nancumsum_impl(arr, like_pandas=False):
             partial_sum = numpy.zeros(len(chunks), dtype=retty)
             result = numpy.empty_like(arr)
 
+            # below line is only needed since Literal[bool] var cannot be converted to bool
+            # in a prange due to a bug related to absence of BooleanLiterals in Numba
+            _like_pandas = True if like_pandas else False
             for i in prange(len(chunks)):
                 chunk = chunks[i]
                 partial = zero
                 for j in range(chunk.start, chunk.stop):
-                    if like_pandas:
+                    if _like_pandas:
                         result[j] = partial + arr[j]
                         if ~is_nan(arr[j]):
                             partial = result[j]

sdc/tests/test_indexes.py

@@ -34,7 +34,7 @@
 from sdc.tests.test_base import TestCase
 from sdc.utilities.sdc_typing_utils import kwsparams2list
 from sdc.tests.test_series import _make_func_from_text
-from numba.errors import TypingError
+from numba.core.errors import TypingError
 
 
 test_global_index_names = [None, 'abc', 'index']

sdc/tests/test_rolling.py

@@ -41,7 +41,8 @@
 from sdc.tests.test_series import gen_frand_array
 from sdc.tests.test_utils import (count_array_REPs, count_parfor_REPs,
                                   skip_numba_jit, skip_sdc_jit,
-                                  test_global_input_data_float64)
+                                  test_global_input_data_float64,
+                                  assert_raises_ty_checker)
 
 
 LONG_TEST = (int(os.environ['SDC_LONG_ROLLING_TEST']) != 0
@@ -480,42 +481,42 @@ def test_impl(obj, window, min_periods, center,
                                win_type, on, axis, closed).min()
 
         hpat_func = self.jit(test_impl)
-        msg_tmpl = 'Method rolling(). The object {}\n given: {}\n expected: {}'
 
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, '1', None, False, None, None, 0, None)
-        msg = msg_tmpl.format('window', 'unicode_type', 'int')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, '1', False, None, None, 0, None)
-        msg = msg_tmpl.format('min_periods', 'unicode_type', 'None, int')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, None, 0, None, None, 0, None)
-        msg = msg_tmpl.format('center', 'int64', 'bool')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, None, False, -1, None, 0, None)
-        msg = msg_tmpl.format('win_type', 'int64', 'str')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, None, False, None, -1, 0, None)
-        msg = msg_tmpl.format('on', 'int64', 'str')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, None, False, None, None, None, None)
-        msg = msg_tmpl.format('axis', 'none', 'int, str')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, None, False, None, None, 0, -1)
-        msg = msg_tmpl.format('closed', 'int64', 'str')
-        self.assertIn(msg, str(raises.exception))
+        method_name = 'Method rolling().'
+        assert_raises_ty_checker(self,
+                                 [method_name, 'window', 'unicode_type', 'int'],
+                                 hpat_func,
+                                 obj, '1', None, False, None, None, 0, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'min_periods', 'unicode_type', 'None, int'],
+                                 hpat_func,
+                                 obj, 1, '1', False, None, None, 0, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'center', 'int64', 'bool'],
+                                 hpat_func,
+                                 obj, 1, None, 0, None, None, 0, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'win_type', 'int64', 'str'],
+                                 hpat_func,
+                                 obj, 1, None, False, -1, None, 0, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'on', 'int64', 'str'],
+                                 hpat_func,
+                                 obj, 1, None, False, None, -1, 0, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'axis', 'none', 'int, str'],
+                                 hpat_func,
+                                 obj, 1, None, False, None, None, None, None)
+
+        assert_raises_ty_checker(self,
+                                 [method_name, 'closed', 'int64', 'str'],
+                                 hpat_func,
+                                 obj, 1, None, False, None, None, 0, -1)
 
     def _test_rolling_apply_mean(self, obj):
         def test_impl(obj, window, min_periods):
@@ -548,10 +549,10 @@ def func(x):
 
         hpat_func = self.jit(test_impl)
 
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1)
-        msg = 'Method rolling.apply(). The object raw\n given: int64\n expected: bool'
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 ['Method rolling.apply().', 'raw', 'int64', 'bool'],
+                                 hpat_func,
+                                 obj, 1)
 
     def _test_rolling_apply_args(self, obj):
         def test_impl(obj, window, min_periods, q):
@@ -610,10 +611,10 @@ def test_impl(obj, pairwise):
 
         hpat_func = self.jit(test_impl)
 
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1)
-        msg = 'Method rolling.corr(). The object pairwise\n given: int64\n expected: bool'
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 ['Method rolling.corr().', 'pairwise', 'int64', 'bool'],
+                                 hpat_func,
+                                 obj, 1)
 
     def _test_rolling_count(self, obj):
         def test_impl(obj, window, min_periods):
@@ -666,17 +667,16 @@ def test_impl(obj, pairwise, ddof):
 
         hpat_func = self.jit(test_impl)
 
-        msg_tmpl = 'Method rolling.cov(). The object {}\n given: {}\n expected: {}'
+        method_name = 'Method rolling.cov().'
+        assert_raises_ty_checker(self,
+                                 [method_name, 'pairwise', 'int64', 'bool'],
+                                 hpat_func,
+                                 obj, 1, 1)
 
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 1, 1)
-        msg = msg_tmpl.format('pairwise', 'int64', 'bool')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, None, '1')
-        msg = msg_tmpl.format('ddof', 'unicode_type', 'int')
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 [method_name, 'ddof', 'unicode_type', 'int'],
+                                 hpat_func,
+                                 obj, None, '1')
 
     def _test_rolling_kurt(self, obj):
         def test_impl(obj, window, min_periods):
@@ -777,17 +777,16 @@ def test_impl(obj, quantile, interpolation):
 
         hpat_func = self.jit(test_impl)
 
-        msg_tmpl = 'Method rolling.quantile(). The object {}\n given: {}\n expected: {}'
+        method_name = 'Method rolling.quantile().'
+        assert_raises_ty_checker(self,
+                                 [method_name, 'quantile', 'unicode_type', 'float'],
+                                 hpat_func,
+                                 obj, '0.5', 'linear')
 
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, '0.5', 'linear')
-        msg = msg_tmpl.format('quantile', 'unicode_type', 'float')
-        self.assertIn(msg, str(raises.exception))
-
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, 0.5, None)
-        msg = msg_tmpl.format('interpolation', 'none', 'str')
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 [method_name, 'interpolation', 'none', 'str'],
+                                 hpat_func,
+                                 obj, 0.5, None)
 
     def _test_rolling_quantile_exception_unsupported_values(self, obj):
         def test_impl(obj, quantile, interpolation):
@@ -836,10 +835,10 @@ def _test_rolling_std_exception_unsupported_ddof(self, obj):
         hpat_func = self.jit(test_impl)
 
         window, min_periods, invalid_ddof = 3, 2, '1'
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, window, min_periods, invalid_ddof)
-        msg = 'Method rolling.std(). The object ddof\n given: unicode_type\n expected: int'
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 ['Method rolling.std().', 'ddof', 'unicode_type', 'int'],
+                                 hpat_func,
+                                 obj, window, min_periods, invalid_ddof)
 
     def _test_rolling_sum(self, obj):
         def test_impl(obj, window, min_periods):
@@ -874,10 +873,10 @@ def _test_rolling_var_exception_unsupported_ddof(self, obj):
         hpat_func = self.jit(test_impl)
 
         window, min_periods, invalid_ddof = 3, 2, '1'
-        with self.assertRaises(TypingError) as raises:
-            hpat_func(obj, window, min_periods, invalid_ddof)
-        msg = 'Method rolling.var(). The object ddof\n given: unicode_type\n expected: int'
-        self.assertIn(msg, str(raises.exception))
+        assert_raises_ty_checker(self,
+                                 ['Method rolling.var().', 'ddof', 'unicode_type', 'int'],
+                                 hpat_func,
+                                 obj, window, min_periods, invalid_ddof)
 
     @skip_sdc_jit('DataFrame.rolling.min() unsupported exceptions')
     def test_df_rolling_unsupported_values(self):