Series rename new pipeline (#373)

* Init Series.rename method in new pipeline

 - Add 10 new tests
 - Rename using non-string types not works

* Skip 4 rename tests with int and float types

 - Required Series name support for full scalar types (not only str)

Author: Vyacheslav-Smirnov

sdc/datatypes/hpat_pandas_series_functions.py

@@ -2147,6 +2147,77 @@ def hpat_pandas_series_quantile_impl(self, q=0.5, interpolation='linear'):
     return hpat_pandas_series_quantile_impl
 
 
+@overload_method(SeriesType, 'rename')
+def hpat_pandas_series_rename(self, index=None, copy=True, inplace=False, level=None):
+    """
+    Pandas Series method :meth:`pandas.Series.rename` implementation.
+    Alter Series index labels or name.
+    .. only:: developer
+       Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_rename
+
+    Parameters
+    -----------
+    index : :obj:`scalar` or `hashable sequence` or `dict` or `function`
+               Dict-like or functions are transformations to apply to the index.
+               Scalar or hashable sequence-like will alter the Series.name attribute.
+               Only scalar value is supported.
+    copy : :obj:`bool`, default :obj:`True`
+               Whether to copy underlying data.
+    inplace : :obj:`bool`, default :obj:`False`
+               Whether to return a new Series. If True then value of copy is ignored.
+    level : :obj:`int` or `str`
+               In case of a MultiIndex, only rename labels in the specified level.
+               *Not supported*
+    Returns
+    -------
+    :obj:`pandas.Series`
+         returns :obj:`pandas.Series` with index labels or name altered.
+    """
+
+    ty_checker = TypeChecker('Method rename().')
+    ty_checker.check(self, SeriesType)
+
+    if not isinstance(index, (types.Omitted, types.UnicodeType,
+                              types.StringLiteral, str,
+                              types.Integer, types.Boolean,
+                              types.Hashable, types.Float,
+                              types.NPDatetime, types.NPTimedelta,
+                              types.Number)) and index is not None:
+        ty_checker.raise_exc(index, 'string', 'index')
+
+    if not isinstance(copy, (types.Omitted, types.Boolean, bool)):
+        ty_checker.raise_exc(copy, 'boolean', 'copy')
+
+    if not isinstance(inplace, (types.Omitted, types.Boolean, bool)):
+        ty_checker.raise_exc(inplace, 'boolean', 'inplace')
+
+    if not isinstance(level, (types.Omitted, types.UnicodeType,
+                              types.StringLiteral, types.Integer)) and level is not None:
+        ty_checker.raise_exc(level, 'Integer or srting', 'level')
+
+    def hpat_pandas_series_rename_idx_impl(self, index=None, copy=True, inplace=False, level=None):
+        if copy is True:
+            series_data = self._data.copy()
+            series_index = self._index.copy()
+        else:
+            series_data = self._data
+            series_index = self._index
+
+        return pandas.Series(data=series_data, index=series_index, name=index)
+
+    def hpat_pandas_series_rename_noidx_impl(self, index=None, copy=True, inplace=False, level=None):
+        if copy is True:
+            series_data = self._data.copy()
+        else:
+            series_data = self._data
+
+        return pandas.Series(data=series_data, index=self._index, name=index)
+
+    if isinstance(self.index, types.NoneType):
+        return hpat_pandas_series_rename_noidx_impl
+    return hpat_pandas_series_rename_idx_impl
+
+
 @overload_method(SeriesType, 'min')
 def hpat_pandas_series_min(self, axis=None, skipna=True, level=None, numeric_only=None):
     """

sdc/hiframes/hiframes_typed.py

@@ -899,15 +899,15 @@ def run_call_series_quantile_default(A):
         if func_name == 'dropna':
             return self._run_call_series_dropna(assign, lhs, rhs, series_var)
 
-        if func_name == 'rename':
-            nodes = []
-            data = self._get_series_data(series_var, nodes)
-            index = self._get_series_index(series_var, nodes)
-            name = rhs.args[0]
-            return self._replace_func(
-                lambda data, index, name: sdc.hiframes.api.init_series(
-                    data, index, name),
-                [data, index, name], pre_nodes=nodes)
+        # if func_name == 'rename':
+        #     nodes = []
+        #     data = self._get_series_data(series_var, nodes)
+        #     index = self._get_series_index(series_var, nodes)
+        #     name = rhs.args[0]
+        #     return self._replace_func(
+        #         lambda data, index, name: sdc.hiframes.api.init_series(
+        #             data, index, name),
+        #         [data, index, name], pre_nodes=nodes)
 
         if func_name == 'pct_change':
             nodes = []

sdc/hiframes/pd_series_ext.py

@@ -729,13 +729,13 @@ def resolve_head(self, ary, args, kws):
     #         types.int64, types.Array(types.int64, 1, 'C'), ary.data)
     #     return signature(out, *args)
 
-    @bound_function("series.rename")
-    def resolve_rename(self, ary, args, kws):
-        # TODO: support index rename, kws
-        assert len(args) == 1 and isinstance(
-            args[0], (types.UnicodeType, types.StringLiteral))
-        out = SeriesType(ary.dtype, ary.data, ary.index, True)
-        return signature(out, *args)
+    # @bound_function("series.rename")
+    # def resolve_rename(self, ary, args, kws):
+    #     # TODO: support index rename, kws
+    #     assert len(args) == 1 and isinstance(
+    #         args[0], (types.UnicodeType, types.StringLiteral))
+    #     out = SeriesType(ary.dtype, ary.data, ary.index, True)
+    #     return signature(out, *args)
 
 
 # TODO: use ops logic from pandas/core/ops.py

sdc/tests/test_series.py

@@ -1771,19 +1771,102 @@ def test_impl(S):
         S2 = S1.copy()
         pd.testing.assert_series_equal(hpat_func(S1), test_impl(S2))
 
-    @unittest.skip('numba.errors.TypingError - fix needed\n'
-                   'Failed in hpat mode pipeline'
-                   '(step: convert to distributed)\n'
-                   'Invalid use of Function(<built-in function len>)'
-                   'with argument(s) of type(s): (none)\n')
-    def test_series_rename1(self):
+    def test_series_rename_str_df_noidx(self):
         def test_impl(A):
             return A.rename('B')
         hpat_func = self.jit(test_impl)
 
         df = pd.DataFrame({'A': [1.0, 2.0, np.nan, 1.0]})
         pd.testing.assert_series_equal(hpat_func(df.A), test_impl(df.A))
 
+    def test_series_rename_str_noidx(self):
+        def test_impl(S):
+            return S.rename('Name')
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3])
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    def test_series_rename_str_idx(self):
+        def test_impl(S):
+            return S.rename('Name')
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    def test_series_rename_no_name_str_noidx(self):
+        def test_impl(S):
+            return S.rename()
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    def test_series_rename_no_name_str_idx(self):
+        def test_impl(S):
+            return S.rename()
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], index=['a', 'b', 'c'], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    def test_series_rename_str_noidx_no_copy(self):
+        def test_impl(S):
+            return S.rename('Another Name', copy=False)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    def test_series_rename_str_idx_no_copy(self):
+        def test_impl(S):
+            return S.rename('Another Name', copy=False)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], index=['a', 'b', 'c'], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    @skip_sdc_jit("Requires full scalar types (not only str) support as Series name")
+    @skip_numba_jit("Requires full scalar types (not only str) support as Series name")
+    def test_series_rename_int_noidx(self):
+        def test_impl(S):
+            return S.rename(1)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    @skip_sdc_jit("Requires full scalar types (not only str) support as Series name")
+    @skip_numba_jit("Requires full scalar types (not only str) support as Series name")
+    def test_series_rename_int_idx(self):
+        def test_impl(S):
+            return S.rename(1)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], index=['a', 'b', 'c'], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    @skip_sdc_jit("Requires full scalar types (not only str) support as Series name")
+    @skip_numba_jit("Requires full scalar types (not only str) support as Series name")
+    def test_series_rename_float_noidx(self):
+        def test_impl(S):
+            return S.rename(1.1)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
+    @skip_sdc_jit("Requires full scalar types (not only str) support as Series name")
+    @skip_numba_jit("Requires full scalar types (not only str) support as Series name")
+    def test_series_rename_float_idx(self):
+        def test_impl(S):
+            return S.rename(1.1)
+        jit_func = self.jit(test_impl)
+
+        S = pd.Series([1, 2, 3], index=['a', 'b', 'c'], name='Name')
+        pd.testing.assert_series_equal(jit_func(S), test_impl(S))
+
     def test_series_sum_default(self):
         def test_impl(S):
             return S.sum()