From 16b70a8efbff6cde51a808ec0ad7cfdcab6bbab4 Mon Sep 17 00:00:00 2001 From: akharche Date: Wed, 2 Oct 2019 15:45:51 +0300 Subject: [PATCH 1/7] Series.max() in new style --- .../datatypes/hpat_pandas_series_functions.py | 53 +++++++++++++++++++ hpat/hiframes/hiframes_typed.py | 2 +- hpat/hiframes/pd_series_ext.py | 14 ++--- 3 files changed, 61 insertions(+), 8 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index 1ef9d6545..ca372b757 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -33,6 +33,7 @@ import operator import pandas +import numpy as np from numba import types from numba.extending import (types, overload, overload_method, overload_attribute) @@ -1128,3 +1129,55 @@ def hpat_pandas_series_le_impl(self, other): return hpat_pandas_series_le_impl raise TypingError('{} The object must be a pandas.series and argument must be a number. Given: {} and other: {}'.format(_func_name, self, other)) + + +@overload_method(SeriesType, 'max') +def hpat_pandas_series_max(self, axis=0, skipna=True, level=None, numeric_only=None): + """ + Pandas Series method :meth:`pandas.Series.max` implementation. + + .. only:: developer + + Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max1 + + Parameters + ----------- + axis: + *unsupported* + skipna: :obj:`bool` object + Exclude nan values when computing the result + level: + *unsupported* + numeric_only: + *unsupported* + + Returns + ------- + :obj: + returns :obj: scalar + """ + + _func_name = 'Method max().' + + if not isinstance(self, SeriesType): + raise TypingError( + '{} The object must be a pandas.series. Given self: {}'.format(_func_name, self)) + + if not isinstance(skipna, (types.Omitted, bool)): + raise TypingError( + '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, type(skipna))) + + if not (isinstance(axis, types.Omitted) or axis == 0) \ + or not (isinstance(level, types.Omitted) or level is None) \ + or not (isinstance(numeric_only, types.Omitted) or numeric_only is None): + raise TypingError( + '{} Unsupported parameters. Given axis: {}, level: {}, numeric_only: {}'.format(_func_name, axis, level, + numeric_only)) + + def hpat_pandas_series_max_impl(self, axis=0, skipna=True, level=None, numeric_only=None): + if skipna: + return np.nanmax(self._data) + else: + return self._data.max() + + return hpat_pandas_series_max_impl diff --git a/hpat/hiframes/hiframes_typed.py b/hpat/hiframes/hiframes_typed.py index c6ab31e77..12a840411 100644 --- a/hpat/hiframes/hiframes_typed.py +++ b/hpat/hiframes/hiframes_typed.py @@ -846,7 +846,7 @@ def parse_impl(data): def _run_call_series(self, assign, lhs, rhs, series_var, func_name): # single arg functions - if func_name in ('sum', 'count', 'mean', 'var', 'min', 'max', 'prod'): + if func_name in ('sum', 'count', 'mean', 'var', 'min', 'prod'): if rhs.args or rhs.kws: raise ValueError("unsupported Series.{}() arguments".format( func_name)) diff --git a/hpat/hiframes/pd_series_ext.py b/hpat/hiframes/pd_series_ext.py index 00cbf5c7d..4db9104fb 100644 --- a/hpat/hiframes/pd_series_ext.py +++ b/hpat/hiframes/pd_series_ext.py @@ -700,13 +700,13 @@ def resolve_idxmax(self, ary, args, kws): assert not kws return signature(types.intp, *args) - @bound_function("series.max") - def resolve_max(self, ary, args, kws): - assert not kws - dtype = ary.dtype - dtype = (pandas_timestamp_type - if isinstance(dtype, types.NPDatetime) else dtype) - return signature(dtype, *args) + # @bound_function("series.max") + # def resolve_max(self, ary, args, kws): + # assert not kws + # dtype = ary.dtype + # dtype = (pandas_timestamp_type + # if isinstance(dtype, types.NPDatetime) else dtype) + # return signature(dtype, *args) @bound_function("series.min") def resolve_min(self, ary, args, kws): From 7a25ddd75da5d464e2a3624b02c301b80e90144c Mon Sep 17 00:00:00 2001 From: akharche Date: Thu, 3 Oct 2019 15:24:22 +0300 Subject: [PATCH 2/7] Adjust parameters in function --- hpat/datatypes/hpat_pandas_series_functions.py | 14 +++++++++----- hpat/hiframes/series_kernels.py | 2 +- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index ca372b757..522bc6d0f 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -33,7 +33,7 @@ import operator import pandas -import numpy as np +import numpy from numba import types from numba.extending import (types, overload, overload_method, overload_attribute) @@ -1132,7 +1132,7 @@ def hpat_pandas_series_le_impl(self, other): @overload_method(SeriesType, 'max') -def hpat_pandas_series_max(self, axis=0, skipna=True, level=None, numeric_only=None): +def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_only=None): """ Pandas Series method :meth:`pandas.Series.max` implementation. @@ -1163,20 +1163,24 @@ def hpat_pandas_series_max(self, axis=0, skipna=True, level=None, numeric_only=N raise TypingError( '{} The object must be a pandas.series. Given self: {}'.format(_func_name, self)) + if not isinstance(self.dtype, (types.Integer, types.Float)): + raise TypingError( + '{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.dtype)) + if not isinstance(skipna, (types.Omitted, bool)): raise TypingError( '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, type(skipna))) - if not (isinstance(axis, types.Omitted) or axis == 0) \ + if not (isinstance(axis, types.Omitted) or axis is None) \ or not (isinstance(level, types.Omitted) or level is None) \ or not (isinstance(numeric_only, types.Omitted) or numeric_only is None): raise TypingError( '{} Unsupported parameters. Given axis: {}, level: {}, numeric_only: {}'.format(_func_name, axis, level, numeric_only)) - def hpat_pandas_series_max_impl(self, axis=0, skipna=True, level=None, numeric_only=None): + def hpat_pandas_series_max_impl(self, axis=None, skipna=True, level=None, numeric_only=None): if skipna: - return np.nanmax(self._data) + return numpy.nanmax(self._data) else: return self._data.max() diff --git a/hpat/hiframes/series_kernels.py b/hpat/hiframes/series_kernels.py index 416a54159..9a4e81b4b 100644 --- a/hpat/hiframes/series_kernels.py +++ b/hpat/hiframes/series_kernels.py @@ -496,7 +496,7 @@ def gt_f(a, b): 'prod': _column_prod_impl_basic, 'count': _column_count_impl, 'mean': _column_mean_impl, - 'max': defaultdict(lambda: _column_max_impl, [(types.NPDatetime('ns'), _column_max_impl_no_isnan)]), + # 'max': defaultdict(lambda: _column_max_impl, [(types.NPDatetime('ns'), _column_max_impl_no_isnan)]), 'min': defaultdict(lambda: _column_min_impl, [(types.NPDatetime('ns'), _column_min_impl_no_isnan)]), 'var': _column_var_impl, 'std': _column_std_impl, From 9be3368323759445d09756359c280d1f5f20caf9 Mon Sep 17 00:00:00 2001 From: akharche Date: Fri, 4 Oct 2019 14:08:39 +0300 Subject: [PATCH 3/7] Set skipna=None --- hpat/datatypes/hpat_pandas_series_functions.py | 17 ++++++++++------- hpat/hiframes/pd_series_ext.py | 2 +- hpat/tests/test_series.py | 9 +++++++++ 3 files changed, 20 insertions(+), 8 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index af43b2f29..ba54205b6 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -778,13 +778,14 @@ def hpat_pandas_series_pow_impl(self, other): @overload_method(SeriesType, 'max') -def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_only=None): +def hpat_pandas_series_max(self, axis=None, skipna=None, level=None, numeric_only=None): """ Pandas Series method :meth:`pandas.Series.max` implementation. .. only:: developer Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max1 + python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max_param Parameters ----------- @@ -809,10 +810,9 @@ def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_onl raise TypingError('{} The object must be a pandas.series. Given self: {}'.format(_func_name, self)) if not isinstance(self.dtype, (types.Integer, types.Float)): - raise TypingError( - '{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.dtype)) + raise TypingError('{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.dtype)) - if not isinstance(skipna, (types.Omitted, bool)): + if not (isinstance(skipna, (types.Omitted, types.Boolean)) or skipna is None): raise TypingError( '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, type(skipna))) @@ -823,11 +823,14 @@ def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_onl '{} Unsupported parameters. Given axis: {}, level: {}, numeric_only: {}'.format(_func_name, axis, level, numeric_only)) - def hpat_pandas_series_max_impl(self, axis=None, skipna=True, level=None, numeric_only=None): + def hpat_pandas_series_max_impl(self, axis=None, skipna=None, level=None, numeric_only=None): + if skipna is None: + skipna = True + if skipna: return numpy.nanmax(self._data) - else: - return self._data.max() + + return self._data.max() return hpat_pandas_series_max_impl diff --git a/hpat/hiframes/pd_series_ext.py b/hpat/hiframes/pd_series_ext.py index fdafad4fc..3e2f48422 100644 --- a/hpat/hiframes/pd_series_ext.py +++ b/hpat/hiframes/pd_series_ext.py @@ -240,6 +240,7 @@ def __init__(self, dmm, fe_type): make_attribute_wrapper(SeriesType, 'index', '_index') make_attribute_wrapper(SeriesType, 'name', '_name') +from hpat.datatypes.hpat_pandas_series_functions import * @lower_builtin('getiter', SeriesType) def getiter_series(context, builder, sig, args): @@ -1279,4 +1280,3 @@ def hpat_pandas_series_ctor_impl(data=None, index=None, dtype=None, name=None, c return hpat_pandas_series_ctor_impl -from hpat.datatypes.hpat_pandas_series_functions import * diff --git a/hpat/tests/test_series.py b/hpat/tests/test_series.py index f0b99eb12..fd375cd87 100644 --- a/hpat/tests/test_series.py +++ b/hpat/tests/test_series.py @@ -910,6 +910,15 @@ def test_impl(S): S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) + def test_series_max_param(self): + def test_impl(S): + return S.max(skipna=True) + + hpat_func = hpat.jit(test_impl) + + S = pd.Series([np.nan, 2., 3., 1, -1000]) + self.assertEqual(hpat_func(S), test_impl(S)) + def test_series_value_counts(self): def test_impl(S): return S.value_counts() From b44ff60e35d0c2e4f91e1d7705bad0a5191f1e3b Mon Sep 17 00:00:00 2001 From: Sergey Shalnov Date: Tue, 8 Oct 2019 19:56:47 -0500 Subject: [PATCH 4/7] PR189. Change parameter default value --- hpat/datatypes/hpat_pandas_series_functions.py | 15 ++++++--------- hpat/tests/test_series.py | 4 ++-- 2 files changed, 8 insertions(+), 11 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index ba54205b6..83903f54c 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -778,7 +778,7 @@ def hpat_pandas_series_pow_impl(self, other): @overload_method(SeriesType, 'max') -def hpat_pandas_series_max(self, axis=None, skipna=None, level=None, numeric_only=None): +def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_only=None): """ Pandas Series method :meth:`pandas.Series.max` implementation. @@ -809,12 +809,12 @@ def hpat_pandas_series_max(self, axis=None, skipna=None, level=None, numeric_onl if not isinstance(self, SeriesType): raise TypingError('{} The object must be a pandas.series. Given self: {}'.format(_func_name, self)) - if not isinstance(self.dtype, (types.Integer, types.Float)): - raise TypingError('{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.dtype)) + if not isinstance(self.data.dtype, (types.Integer, types.Float)): + raise TypingError('{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.data.dtype)) - if not (isinstance(skipna, (types.Omitted, types.Boolean)) or skipna is None): + if not isinstance(skipna, (types.Omitted, types.Boolean)) and skipna is not True: raise TypingError( - '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, type(skipna))) + '{} The parameter must be a boolean type. Given type skipna: {}'.format(_func_name, skipna)) if not (isinstance(axis, types.Omitted) or axis is None) \ or not (isinstance(level, types.Omitted) or level is None) \ @@ -823,10 +823,7 @@ def hpat_pandas_series_max(self, axis=None, skipna=None, level=None, numeric_onl '{} Unsupported parameters. Given axis: {}, level: {}, numeric_only: {}'.format(_func_name, axis, level, numeric_only)) - def hpat_pandas_series_max_impl(self, axis=None, skipna=None, level=None, numeric_only=None): - if skipna is None: - skipna = True - + def hpat_pandas_series_max_impl(self, axis=None, skipna=True, level=None, numeric_only=None): if skipna: return numpy.nanmax(self._data) diff --git a/hpat/tests/test_series.py b/hpat/tests/test_series.py index fd375cd87..f09a1715f 100644 --- a/hpat/tests/test_series.py +++ b/hpat/tests/test_series.py @@ -907,7 +907,7 @@ def test_impl(S): return S.max() hpat_func = hpat.jit(test_impl) - S = pd.Series([np.nan, 2., 3.]) + S = pd.Series([np.nan, 2., 3., np.inf]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_max_param(self): @@ -916,7 +916,7 @@ def test_impl(S): hpat_func = hpat.jit(test_impl) - S = pd.Series([np.nan, 2., 3., 1, -1000]) + S = pd.Series([np.nan, 2., 3., 1, -1000, np.inf]) self.assertEqual(hpat_func(S), test_impl(S)) def test_series_value_counts(self): From 6f6ff208f80bc87d7e6de115b720fef68dc2ebeb Mon Sep 17 00:00:00 2001 From: Sergey Shalnov Date: Tue, 8 Oct 2019 20:05:53 -0500 Subject: [PATCH 5/7] PR189. Typo fixed --- hpat/datatypes/hpat_pandas_series_functions.py | 1 - hpat/hiframes/pd_series_ext.py | 2 +- 2 files changed, 1 insertion(+), 2 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index e9d79cd56..658edc3a4 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -1362,4 +1362,3 @@ def hpat_pandas_series_abs_impl(self): return pandas.Series(numpy.abs(self._data)) return hpat_pandas_series_abs_impl - diff --git a/hpat/hiframes/pd_series_ext.py b/hpat/hiframes/pd_series_ext.py index 39d450ad4..fdaa5566b 100644 --- a/hpat/hiframes/pd_series_ext.py +++ b/hpat/hiframes/pd_series_ext.py @@ -240,7 +240,6 @@ def __init__(self, dmm, fe_type): make_attribute_wrapper(SeriesType, 'index', '_index') make_attribute_wrapper(SeriesType, 'name', '_name') -from hpat.datatypes.hpat_pandas_series_functions import * @lower_builtin('getiter', SeriesType) def getiter_series(context, builder, sig, args): @@ -1280,3 +1279,4 @@ def hpat_pandas_series_ctor_impl(data=None, index=None, dtype=None, name=None, c return hpat_pandas_series_ctor_impl +from hpat.datatypes.hpat_pandas_series_functions import * From 6d8ae03030f73707cbeba1aeac6e68dcdf59fc10 Mon Sep 17 00:00:00 2001 From: Sergey Shalnov Date: Wed, 9 Oct 2019 18:59:11 -0500 Subject: [PATCH 6/7] PR189. Tests impoved and revert back paralellization --- .../datatypes/hpat_pandas_series_functions.py | 2 +- hpat/hiframes/hiframes_typed.py | 6 ++--- hpat/hiframes/pd_series_ext.py | 3 ++- hpat/hiframes/series_kernels.py | 2 +- hpat/tests/test_series.py | 27 ++++++++++++++----- 5 files changed, 27 insertions(+), 13 deletions(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index 658edc3a4..9e651f23a 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -926,7 +926,7 @@ def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_onl .. only:: developer - Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max1 + Test: python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max python -m hpat.runtests hpat.tests.test_series.TestSeries.test_series_max_param Parameters diff --git a/hpat/hiframes/hiframes_typed.py b/hpat/hiframes/hiframes_typed.py index 0a369f44b..c1f799eb0 100644 --- a/hpat/hiframes/hiframes_typed.py +++ b/hpat/hiframes/hiframes_typed.py @@ -851,10 +851,10 @@ def parse_impl(data): def _run_call_series(self, assign, lhs, rhs, series_var, func_name): # single arg functions - if func_name in ('sum', 'count', 'mean', 'var', 'min', 'prod'): + if func_name in ('sum', 'count', 'mean', 'var', 'min', 'max', 'prod'): if rhs.args or rhs.kws: - raise ValueError("unsupported Series.{}() arguments".format( - func_name)) + raise ValueError("HPAT pipeline does not support arguments for Series.{}()".format(func_name)) + # TODO: handle skipna, min_count arguments series_typ = self.typemap[series_var.name] series_dtype = series_typ.dtype diff --git a/hpat/hiframes/pd_series_ext.py b/hpat/hiframes/pd_series_ext.py index fdaa5566b..e5f0755a0 100644 --- a/hpat/hiframes/pd_series_ext.py +++ b/hpat/hiframes/pd_series_ext.py @@ -986,7 +986,8 @@ def generic_expand_cumulative_series(self, args, kws): install_array_method(fname, generic_expand_cumulative_series) # TODO: add itemsize, strides, etc. when removed from Pandas -_not_series_array_attrs = ['flat', 'ctypes', 'itemset', 'reshape', 'sort', 'flatten', 'resolve_take'] +_not_series_array_attrs = ['flat', 'ctypes', 'itemset', 'reshape', 'sort', 'flatten', + 'resolve_take', 'resolve_max'] # use ArrayAttribute for attributes not defined in SeriesAttribute for attr, func in numba.typing.arraydecl.ArrayAttribute.__dict__.items(): diff --git a/hpat/hiframes/series_kernels.py b/hpat/hiframes/series_kernels.py index f152eab7c..71742351c 100644 --- a/hpat/hiframes/series_kernels.py +++ b/hpat/hiframes/series_kernels.py @@ -496,7 +496,7 @@ def gt_f(a, b): 'prod': _column_prod_impl_basic, 'count': _column_count_impl, 'mean': _column_mean_impl, - # 'max': defaultdict(lambda: _column_max_impl, [(types.NPDatetime('ns'), _column_max_impl_no_isnan)]), + 'max': defaultdict(lambda: _column_max_impl, [(types.NPDatetime('ns'), _column_max_impl_no_isnan)]), 'min': defaultdict(lambda: _column_min_impl, [(types.NPDatetime('ns'), _column_min_impl_no_isnan)]), 'var': _column_var_impl, 'std': _column_std_impl, diff --git a/hpat/tests/test_series.py b/hpat/tests/test_series.py index e9356a4c0..f91e8484f 100644 --- a/hpat/tests/test_series.py +++ b/hpat/tests/test_series.py @@ -916,22 +916,35 @@ def test_impl(S): S = pd.Series([np.nan, 2., 3.]) self.assertEqual(hpat_func(S), test_impl(S)) - def test_series_max1(self): + def test_series_max(self): def test_impl(S): return S.max() hpat_func = hpat.jit(test_impl) - S = pd.Series([np.nan, 2., 3., np.inf]) - self.assertEqual(hpat_func(S), test_impl(S)) + # TODO type_min/type_max + for input_data in [[np.nan, 2., np.nan, 3., np.inf, 1, -1000], + [8, 31, 1123, -1024], + [2., 3., 1, -1000, np.inf]]: + S = pd.Series(input_data) + + result_ref = test_impl(S) + result = hpat_func(S) + self.assertEqual(result, result_ref) + @unittest.skipIf(hpat.config.config_pipeline_hpat_default, "Series.max() any parameters unsupported") def test_series_max_param(self): - def test_impl(S): - return S.max(skipna=True) + def test_impl(S, param_skipna): + return S.max(skipna=param_skipna) hpat_func = hpat.jit(test_impl) - S = pd.Series([np.nan, 2., 3., 1, -1000, np.inf]) - self.assertEqual(hpat_func(S), test_impl(S)) + for input_data, param_skipna in [([np.nan, 2., np.nan, 3., 1, -1000, np.inf], True), + ([2., 3., 1, np.inf, -1000], False)]: + S = pd.Series(input_data) + + result_ref = test_impl(S, param_skipna) + result = hpat_func(S, param_skipna) + self.assertEqual(result, result_ref) def test_series_value_counts(self): def test_impl(S): From 1f0aaa640bac9d2e139fab9b82f5aac53b963d38 Mon Sep 17 00:00:00 2001 From: Sergey Shalnov Date: Wed, 9 Oct 2019 21:55:09 -0500 Subject: [PATCH 7/7] PR189. Skip datetime tests with series.max() --- hpat/datatypes/hpat_pandas_series_functions.py | 2 +- hpat/tests/test_join.py | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/hpat/datatypes/hpat_pandas_series_functions.py b/hpat/datatypes/hpat_pandas_series_functions.py index 20df08521..71bb8c7a8 100644 --- a/hpat/datatypes/hpat_pandas_series_functions.py +++ b/hpat/datatypes/hpat_pandas_series_functions.py @@ -924,7 +924,7 @@ def hpat_pandas_series_max(self, axis=None, skipna=True, level=None, numeric_onl _func_name = 'Method max().' if not isinstance(self, SeriesType): - raise TypingError('{} The object must be a pandas.series. Given self: {}'.format(_func_name, self)) + raise TypingError('{} The object must be a pandas.series. Given: {}'.format(_func_name, self)) if not isinstance(self.data.dtype, (types.Integer, types.Float)): raise TypingError('{} Currently function supports only numeric values. Given data type: {}'.format(_func_name, self.data.dtype)) diff --git a/hpat/tests/test_join.py b/hpat/tests/test_join.py index 7a86e03d8..017affacc 100644 --- a/hpat/tests/test_join.py +++ b/hpat/tests/test_join.py @@ -173,6 +173,7 @@ def test_impl(df1, df2): ['2017-01-01', '2017-01-06', '2017-01-03']), 'A': [7, 8, 9]}) pd.testing.assert_frame_equal(hpat_func(df1, df2), test_impl(df1, df2)) + @unittest.skip("Method max(). Currently function supports only numeric values. Given data type: datetime64[ns]") def test_join_datetime_parallel1(self): def test_impl(df1, df2): df3 = pd.merge(df1, df2, on='time') @@ -207,6 +208,7 @@ def test_impl(df1, df2): '2017-02-25']), 'A': [2, 3, 7, 8, 9]}) pd.testing.assert_frame_equal(hpat_func(df1, df2), test_impl(df1, df2)) + @unittest.skip("Method max(). Currently function supports only numeric values. Given data type: datetime64[ns]") def test_merge_asof_parallel1(self): def test_impl(): df1 = pd.read_parquet('asof1.pq')