fix Series name for dropna

Author: Ehsan Totoni

hpat/distributed_analysis.py

@@ -103,6 +103,8 @@ def _analyze_block(self, block, array_dists, parfor_dists):
                 self._analyze_parfor(inst, array_dists, parfor_dists)
             elif isinstance(inst, (ir.SetItem, ir.StaticSetItem)):
                 self._analyze_setitem(inst, array_dists)
+            # elif isinstance(inst, ir.Print):
+            #     continue
             elif type(inst) in distributed_analysis_extensions:
                 # let external calls handle stmt if type matches
                 f = distributed_analysis_extensions[type(inst)]

hpat/hiframes/hiframes_typed.py

@@ -1168,27 +1168,29 @@ def _run_call_series_dropna(self, assign, lhs, rhs, series_var):
 
         nodes = []
         data = self._get_series_data(series_var, nodes)
+        name = self._get_series_name(series_var, nodes)
 
         if inplace:
             # Since arrays can't resize inplace, we have to create a new
             # array and assign it back to the same Series variable
             # result back to the same variable
-            def dropna_impl(A):
+            def dropna_impl(A, name):
                 # not using A.dropna since definition list is not working
                 # for A to find callname
-                return hpat.hiframes.api.dropna(A)
+                return hpat.hiframes.api.dropna(A, name)
 
             assign.target = series_var  # replace output
-            return self._replace_func(dropna_impl, [data], pre_nodes=nodes)
+            return self._replace_func(dropna_impl, [data, name], pre_nodes=nodes)
         else:
             if dtype == string_type:
                 func = series_replace_funcs['dropna_str_alloc']
             elif isinstance(dtype, types.Float):
                 func = series_replace_funcs['dropna_float']
             else:
                 # integer case, TODO: bool, date etc.
-                func = lambda A: hpat.hiframes.api.init_series(A)
-            return self._replace_func(func, [data], pre_nodes=nodes)
+                func = lambda A, name: hpat.hiframes.api.init_series(
+                    A, None, name)
+            return self._replace_func(func, [data, name], pre_nodes=nodes)
 
     def _handle_series_map(self, assign, lhs, rhs, series_var):
         """translate df.A.map(lambda a:...) to prange()

hpat/hiframes/pd_series_ext.py

@@ -147,10 +147,11 @@ def is_datetime_date_series_typ(t):
 @register_model(SeriesType)
 class SeriesModel(models.StructModel):
     def __init__(self, dmm, fe_type):
+        name_typ = string_type if fe_type.is_named else types.none
         members = [
             ('data', fe_type.data),
             ('index', fe_type.index),
-            ('name', string_type),
+            ('name', name_typ),
         ]
         super(SeriesModel, self).__init__(dmm, fe_type, members)
 

hpat/hiframes/series_kernels.py

@@ -57,7 +57,7 @@ def _series_fillna_str_alloc_impl(B, fill):  # pragma: no cover
     hpat.hiframes.api.fillna(A, B, fill)
     return hpat.hiframes.api.init_series(A)
 
-def _series_dropna_float_impl(S):  # pragma: no cover
+def _series_dropna_float_impl(S, name):  # pragma: no cover
     old_len = len(S)
     new_len = old_len - hpat.hiframes.api.init_series(S).isna().sum()
     A = np.empty(new_len, S.dtype)
@@ -68,9 +68,9 @@ def _series_dropna_float_impl(S):  # pragma: no cover
             A[curr_ind] = val
             curr_ind += 1
 
-    return hpat.hiframes.api.init_series(A)
+    return hpat.hiframes.api.init_series(A, None, name)
 
-def _series_dropna_str_alloc_impl(B):  # pragma: no cover
+def _series_dropna_str_alloc_impl(B, name):  # pragma: no cover
     # local_len to enable 1D_Var dist
     # TODO: test
     # TODO: generalize
@@ -81,7 +81,7 @@ def _series_dropna_str_alloc_impl(B):  # pragma: no cover
     A = hpat.str_arr_ext.pre_alloc_string_array(new_len, num_chars)
     hpat.str_arr_ext.copy_non_null_offsets(A, B)
     hpat.str_arr_ext.copy_data(A, B)
-    return hpat.hiframes.api.init_series(A)
+    return hpat.hiframes.api.init_series(A, None, name)
 
 # return the nan value for the type (handle dt64)
 def _get_nan(val):

hpat/utils.py

@@ -197,7 +197,9 @@ def generic(self, args, kws):
 
 typ_to_format = {
     types.int32: 'd',
+    types.uint32: 'u',
     types.int64: 'lld',
+    types.uint64: 'llu',
     types.float32: 'f',
     types.float64: 'lf',
 }