IntelPython · AlexanderKalistratov · Apr 7, 2020 · Apr 2, 2020 · Apr 2, 2020 · Apr 2, 2020
diff --git a/examples/series/str/series_str_contains.py b/examples/series/str/series_str_contains.py
@@ -0,0 +1,38 @@
+# *****************************************************************************
+# Copyright (c) 2019-2020, Intel Corporation All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     Redistributions of source code must retain the above copyright notice,
+#     this list of conditions and the following disclaimer.
+#
+#     Redistributions in binary form must reproduce the above copyright notice,
+#     this list of conditions and the following disclaimer in the documentation
+#     and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+# EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+# *****************************************************************************
+
+import pandas as pd
+from numba import njit
+
+
+@njit
+def series_str_contains():
+    series = pd.Series(['dog', 'foo', 'bar'])
+
+    return series.str.contains('o')  # Expect series of True, True, False
+
+
+print(series_str_contains())
diff --git a/sdc/datatypes/hpat_pandas_stringmethods_functions.py b/sdc/datatypes/hpat_pandas_stringmethods_functions.py
@@ -82,7 +82,7 @@ def hpat_pandas_stringmethods_upper_impl(self):
 
 import numba
 from numba.types import (Boolean, Integer, NoneType,
-                         Omitted, StringLiteral, UnicodeType)
+                         Omitted, StringLiteral, UnicodeType, Number, Set)
 
 from sdc.utilities.sdc_typing_utils import TypeChecker
 from sdc.datatypes.hpat_pandas_stringmethods_types import StringMethodsType
@@ -151,6 +151,87 @@ def hpat_pandas_stringmethods_center_impl(self, width, fillchar=' '):
     return hpat_pandas_stringmethods_center_impl
 
 
+@sdc_overload_method(StringMethodsType, 'contains')
+def hpat_pandas_stringmethods_contains(self, pat, case=True, flags=0, na=None, regex=True):
+    """
+        Intel Scalable Dataframe Compiler User Guide
+        ********************************************
+        Pandas API: pandas.Series.str.contains
+
+        Limitations
+        -----------
+        - Series elements are expected to be Unicode strings. Elements cannot be `NaNs`.
+        - Parameter ``na`` is supported only with default value ``None``.
+        - Parameter ``flags`` is supported only with default value ``0``.
+        - Parameter ``regex`` is supported only with default value ``True``.
+
+        Examples
+        --------
+        .. literalinclude:: ../../../examples/series/str/series_str_contains.py
+           :language: python
+           :lines: 27-
+           :caption: Tests if string element contains a pattern.
+           :name: ex_series_str_contains
+
+        .. command-output:: python ./series/str/series_str_contains.py
+           :cwd: ../../../examples
+
+        .. seealso::
+            :ref:`Series.str.startswith <pandas.Series.str.startswith>`
+                Same as endswith, but tests the start of string.
+            :ref:`Series.str.endswith <pandas.Series.str.endswith>`
+                Same as startswith, but tests the end of string.
+
+        Intel Scalable Dataframe Compiler Developer Guide
+        *************************************************
+
+        Pandas Series method :meth:`pandas.core.strings.StringMethods.contains()` implementation.
+
+        .. only:: developer
+
+        Test: python -m sdc.runtests -k sdc.tests.test_series.TestSeries.test_series_contains
+        """
+
+    ty_checker = TypeChecker('Method contains().')
+    ty_checker.check(self, StringMethodsType)
+
+    if not isinstance(pat, (StringLiteral, UnicodeType)):
+        ty_checker.raise_exc(pat, 'str', 'pat')
+
+    if not isinstance(na, (Omitted, NoneType)) and na is not None:
+        ty_checker.raise_exc(na, 'none', 'na')
+
+    if not isinstance(case, (Boolean, Omitted)) and case is not True:
+        ty_checker.raise_exc(case, 'bool', 'case')
+
+    if not isinstance(flags, (Omitted, Integer)) and flags != 0:
+        ty_checker.raise_exc(flags, 'int64', 'flags')
+
+    if not isinstance(regex, (Omitted, Boolean)) and regex is not True:
+        ty_checker.raise_exc(regex, 'bool', 'regex')
+
+    def hpat_pandas_stringmethods_contains_impl(self, pat, case=True, flags=0, na=None, regex=True):
+        if flags != 0:
+            raise ValueError('Parameter flags can be only 0.')
-            raise ValueError('Parameter flags can be only 0.')
+            raise SDCLimitation("Method contains(). Unsupported parameter. Given 'flags' != 0")
-            raise ValueError('Parameter flags can be only 0.')
+            raise SDCLimitation("Method contains(). Unsupported parameter. Given 'flags' != 0")
+
+        if not regex:
+            raise ValueError('Parameter regex can be only True.')
+
+        if not case:
+            _pat = pat.lower()
+        else:
+            _pat = pat
+
+        len_data = len(self._data)
+        res_list = numpy.empty(len_data, numba.types.boolean)
+        for idx in numba.prange(len_data):
+            res_list[idx] = _pat in self._data._data[idx]
+
+        return pandas.Series(res_list, self._data._index, name=self._data._name)
+
+    return hpat_pandas_stringmethods_contains_impl
+
+
 @sdc_overload_method(StringMethodsType, 'endswith')
 def hpat_pandas_stringmethods_endswith(self, pat, na=None):
     """

diff --git a/sdc/hiframes/pd_series_ext.py b/sdc/hiframes/pd_series_ext.py
@@ -498,7 +498,7 @@ def resolve_value_counts(self, ary, args, kws):
     'lower', 'lstrip', 'rjust', 'rstrip', 'startswith', 'strip', 'zfill',
     'isspace', 'islower', 'isalpha', 'isalnum', 'istitle', 'isnumeric',
     'isdigit', 'isdecimal', 'isupper', 'capitalize', 'title', 'swapcase',
-    'casefold',
+    'casefold', 'contains'
 ]
 """
     Functions which are used from Numba directly by calling from StringMethodsType
@@ -519,9 +519,9 @@ def resolve_value_counts(self, ary, args, kws):
 class SeriesStrMethodAttribute(AttributeTemplate):
     key = StringMethodsType
 
-    @bound_function("strmethod.contains")
-    def resolve_contains(self, ary, args, kws):
-        return signature(SeriesType(types.bool_), *args)
+    # @bound_function("strmethod.contains")
+    # def resolve_contains(self, ary, args, kws):
+    #     return signature(SeriesType(types.bool_), *args)
 
     # @bound_function("strmethod.len")
     # def resolve_len(self, ary, args, kws):

diff --git a/sdc/tests/test_series.py b/sdc/tests/test_series.py
@@ -297,6 +297,10 @@ def rstrip_usecase(series, to_strip=None):
     return series.str.rstrip(to_strip)
 
 
+def contains_usecase(series, pat, case=True, flags=0, na=None, regex=True):
+    return series.str.contains(pat, case, flags, na, regex)
+
+
 class TestSeries(
     TestSeries_apply,
     TestSeries_map,
@@ -6093,6 +6097,41 @@ def test_series_isupper_str(self):
             s = pd.Series(data)
             pd.testing.assert_series_equal(cfunc(s), isupper_usecase(s))
 
+    def test_series_contains(self):
+        hpat_func = self.jit(contains_usecase)
+        s = pd.Series(['Mouse', 'dog', 'house and parrot', '23'])
+        for pat in ['og', 'Og', 'OG', 'o']:
+            for case in [True, False]:
+                with self.subTest(pat=pat, case=case):
+                    pd.testing.assert_series_equal(hpat_func(s, pat, case), contains_usecase(s, pat, case))
+
+    def test_series_contains_with_na_flags_regex(self):
+        hpat_func = self.jit(contains_usecase)
+        s = pd.Series(['Mouse', 'dog', 'house and parrot', '23'])
+        pat = 'og'
+        pd.testing.assert_series_equal(hpat_func(s, pat, flags=0, na=None, regex=True),
+                                       contains_usecase(s, pat, flags=0, na=None, regex=True))
+
+    def test_series_contains_unsupported(self):
+        hpat_func = self.jit(contains_usecase)
+        s = pd.Series(['Mouse', 'dog', 'house and parrot', '23'])
+        pat = 'og'
+
+        with self.assertRaises(ValueError) as raises:
+            hpat_func(s, pat, flags=1)
+        msg = 'Parameter flags can be only 0'
+        self.assertIn(msg, str(raises.exception))
+
+        with self.assertRaises(TypingError) as raises:
+            hpat_func(s, pat, na=0)
+        msg = 'Method contains(). The object na'
+        self.assertIn(msg, str(raises.exception))
+
+        with self.assertRaises(ValueError) as raises:
+            hpat_func(s, pat, regex=False)
+        msg = 'Parameter regex can be only True'
+        self.assertIn(msg, str(raises.exception))
+
     @skip_sdc_jit('Old-style implementation returns string, but not series')
     def test_series_describe_numeric(self):
         def test_impl(A):

diff --git a/sdc/tests/tests_perf/test_perf_series_str.py b/sdc/tests/tests_perf/test_perf_series_str.py
@@ -77,6 +77,7 @@ def _test_case(self, pyfunc, name, total_data_length, input_data=None, data_num=
     TC(name='capitalize', size=[10 ** 4, 10 ** 5]),
     TC(name='casefold', size=[10 ** 4, 10 ** 5]),
     TC(name='center', params='1', size=[10 ** 4, 10 ** 5],  input_data=test_global_input_data_unicode_kind1),
+    TC(name='contains', params='"a"', size=[10 ** 4, 10 ** 5]),
     TC(name='endswith', params='"e"', size=[10 ** 4, 10 ** 5]),
     TC(name='find', params='"e"', size=[10 ** 4, 10 ** 5]),
     TC(name='isalnum', size=[10 ** 4, 10 ** 5]),