snowpark-connect 0.24.0__py3-none-any.whl → 0.26.0__py3-none-any.whl

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/data_type_ops/test_datetime_ops.py

@@ -1,260 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import datetime
-
-import pandas as pd
-from pandas.api.types import CategoricalDtype
-
-from pyspark import pandas as ps
-from pyspark.pandas.tests.data_type_ops.testing_utils import OpsTestBase
-
-
-class DatetimeOpsTestsMixin:
-    @property
-    def pser(self):
-        return pd.Series(pd.date_range("1994-1-31 10:30:15", periods=3, freq="D"))
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    @property
-    def datetime_pdf(self):
-        psers = {
-            "this": self.pser,
-            "that": pd.Series(pd.date_range("1994-2-1 10:30:15", periods=3, freq="D")),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def datetime_psdf(self):
-        return ps.from_pandas(self.datetime_pdf)
-
-    @property
-    def some_datetime(self):
-        return datetime.datetime(1994, 1, 31, 10, 30, 00)
-
-    def test_add(self):
-        self.assertRaises(TypeError, lambda: self.psser + "x")
-        self.assertRaises(TypeError, lambda: self.psser + 1)
-        self.assertRaises(TypeError, lambda: self.psser + self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser + psser)
-
-    def test_sub(self):
-        self.assertRaises(TypeError, lambda: self.psser - "x")
-        self.assertRaises(TypeError, lambda: self.psser - 1)
-        self.assert_eq(
-            (self.pser - self.some_datetime).dt.total_seconds().astype("int"),
-            self.psser - self.some_datetime,
-        )
-
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.df_cols:
-            if col == "datetime":
-                self.assert_eq(
-                    (pdf["datetime"] - pdf[col]).dt.total_seconds().astype("int"),
-                    psdf["datetime"] - psdf[col],
-                )
-            else:
-                self.assertRaises(TypeError, lambda: psdf["datetime"] - psdf[col])
-
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(
-            (pdf["that"] - pdf["this"]).dt.total_seconds().astype("int"),
-            psdf["that"] - psdf["this"],
-        )
-
-    def test_mul(self):
-        self.assertRaises(TypeError, lambda: self.psser * "x")
-        self.assertRaises(TypeError, lambda: self.psser * 1)
-        self.assertRaises(TypeError, lambda: self.psser * self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser * psser)
-
-    def test_truediv(self):
-        self.assertRaises(TypeError, lambda: self.psser / "x")
-        self.assertRaises(TypeError, lambda: self.psser / 1)
-        self.assertRaises(TypeError, lambda: self.psser / self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser / psser)
-
-    def test_floordiv(self):
-        self.assertRaises(TypeError, lambda: self.psser // "x")
-        self.assertRaises(TypeError, lambda: self.psser // 1)
-        self.assertRaises(TypeError, lambda: self.psser // self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser // psser)
-
-    def test_mod(self):
-        self.assertRaises(TypeError, lambda: self.psser % "x")
-        self.assertRaises(TypeError, lambda: self.psser % 1)
-        self.assertRaises(TypeError, lambda: self.psser % self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser % psser)
-
-    def test_pow(self):
-        self.assertRaises(TypeError, lambda: self.psser ** "x")
-        self.assertRaises(TypeError, lambda: self.psser**1)
-        self.assertRaises(TypeError, lambda: self.psser**self.some_datetime)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser**psser)
-
-    def test_radd(self):
-        self.assertRaises(TypeError, lambda: "x" + self.psser)
-        self.assertRaises(TypeError, lambda: 1 + self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime + self.psser)
-
-    def test_rsub(self):
-        self.assertRaises(TypeError, lambda: "x" - self.psser)
-        self.assertRaises(TypeError, lambda: 1 - self.psser)
-        self.assert_eq(
-            (self.some_datetime - self.pser).dt.total_seconds().astype("int"),
-            self.some_datetime - self.psser,
-        )
-
-    def test_rmul(self):
-        self.assertRaises(TypeError, lambda: "x" * self.psser)
-        self.assertRaises(TypeError, lambda: 1 * self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime * self.psser)
-
-    def test_rtruediv(self):
-        self.assertRaises(TypeError, lambda: "x" / self.psser)
-        self.assertRaises(TypeError, lambda: 1 / self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime / self.psser)
-
-    def test_rfloordiv(self):
-        self.assertRaises(TypeError, lambda: "x" // self.psser)
-        self.assertRaises(TypeError, lambda: 1 // self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime // self.psser)
-
-    def test_rmod(self):
-        self.assertRaises(TypeError, lambda: 1 % self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime % self.psser)
-
-    def test_rpow(self):
-        self.assertRaises(TypeError, lambda: "x" ** self.psser)
-        self.assertRaises(TypeError, lambda: 1**self.psser)
-        self.assertRaises(TypeError, lambda: self.some_datetime**self.psser)
-
-    def test_and(self):
-        self.assertRaises(TypeError, lambda: self.psser & True)
-        self.assertRaises(TypeError, lambda: self.psser & False)
-        self.assertRaises(TypeError, lambda: self.psser & self.psser)
-
-    def test_rand(self):
-        self.assertRaises(TypeError, lambda: True & self.psser)
-        self.assertRaises(TypeError, lambda: False & self.psser)
-
-    def test_or(self):
-        self.assertRaises(TypeError, lambda: self.psser | True)
-        self.assertRaises(TypeError, lambda: self.psser | False)
-        self.assertRaises(TypeError, lambda: self.psser | self.psser)
-
-    def test_ror(self):
-        self.assertRaises(TypeError, lambda: True | self.psser)
-        self.assertRaises(TypeError, lambda: False | self.psser)
-
-    def test_from_to_pandas(self):
-        data = pd.date_range("1994-1-31 10:30:15", periods=3, freq="M")
-        pser = pd.Series(data)
-        psser = ps.Series(data)
-        self.assert_eq(pser, psser._to_pandas())
-        self.assert_eq(ps.from_pandas(pser), psser)
-
-    def test_isnull(self):
-        self.assert_eq(self.pser.isnull(), self.psser.isnull())
-
-    def test_astype(self):
-        pser = self.pser
-        psser = self.psser
-        self.assert_eq(pser.astype(str), psser.astype(str))
-        self.assert_eq(pser.astype("category"), psser.astype("category"))
-        cat_type = CategoricalDtype(categories=["a", "b", "c"])
-        self.assert_eq(pser.astype(cat_type), psser.astype(cat_type))
-
-        self.assertRaises(TypeError, lambda: psser.astype(bool))
-
-    def test_neg(self):
-        self.assertRaises(TypeError, lambda: -self.psser)
-
-    def test_abs(self):
-        self.assertRaises(TypeError, lambda: abs(self.psser))
-
-    def test_invert(self):
-        self.assertRaises(TypeError, lambda: ~self.psser)
-
-    def test_eq(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] == pdf["that"], psdf["this"] == psdf["that"])
-        self.assert_eq(pdf["this"] == pdf["this"], psdf["this"] == psdf["this"])
-
-    def test_ne(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] != pdf["that"], psdf["this"] != psdf["that"])
-        self.assert_eq(pdf["this"] != pdf["this"], psdf["this"] != psdf["this"])
-
-    def test_lt(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] < pdf["that"], psdf["this"] < psdf["that"])
-        self.assert_eq(pdf["this"] < pdf["this"], psdf["this"] < psdf["this"])
-
-    def test_le(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] <= pdf["that"], psdf["this"] <= psdf["that"])
-        self.assert_eq(pdf["this"] <= pdf["this"], psdf["this"] <= psdf["this"])
-
-    def test_gt(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] > pdf["that"], psdf["this"] > psdf["that"])
-        self.assert_eq(pdf["this"] > pdf["this"], psdf["this"] > psdf["this"])
-
-    def test_ge(self):
-        pdf, psdf = self.datetime_pdf, self.datetime_psdf
-        self.assert_eq(pdf["this"] >= pdf["that"], psdf["this"] >= psdf["that"])
-        self.assert_eq(pdf["this"] >= pdf["this"], psdf["this"] >= psdf["this"])
-
-
-class DatetimeOpsTests(DatetimeOpsTestsMixin, OpsTestBase):
-    pass
-
-
-class DatetimeNTZOpsTest(DatetimeOpsTests):
-    @classmethod
-    def setUpClass(cls):
-        super(DatetimeOpsTests, cls).setUpClass()
-        cls.spark.conf.set("spark.sql.timestampType", "timestamp_ntz")
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.data_type_ops.test_datetime_ops import *  # noqa: F401
-
-    try:
-        import xmlrunner
-
-        testRunner = xmlrunner.XMLTestRunner(output="target/test-reports", verbosity=2)
-    except ImportError:
-        testRunner = None
-    unittest.main(testRunner=testRunner, verbosity=2)

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/data_type_ops/test_null_ops.py

@@ -1,178 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import pandas as pd
-from pandas.api.types import CategoricalDtype
-
-import pyspark.pandas as ps
-from pyspark.pandas.tests.data_type_ops.testing_utils import OpsTestBase
-
-
-class NullOpsTestsMixin:
-    @property
-    def pser(self):
-        return pd.Series([None, None, None])
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    def test_add(self):
-        self.assertRaises(TypeError, lambda: self.psser + "x")
-        self.assertRaises(TypeError, lambda: self.psser + 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser + psser)
-
-    def test_sub(self):
-        self.assertRaises(TypeError, lambda: self.psser - "x")
-        self.assertRaises(TypeError, lambda: self.psser - 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser - psser)
-
-    def test_mul(self):
-        self.assertRaises(TypeError, lambda: self.psser * "x")
-        self.assertRaises(TypeError, lambda: self.psser * 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser * psser)
-
-    def test_truediv(self):
-        self.assertRaises(TypeError, lambda: self.psser / "x")
-        self.assertRaises(TypeError, lambda: self.psser / 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser / psser)
-
-    def test_floordiv(self):
-        self.assertRaises(TypeError, lambda: self.psser // "x")
-        self.assertRaises(TypeError, lambda: self.psser // 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser // psser)
-
-    def test_mod(self):
-        self.assertRaises(TypeError, lambda: self.psser % "x")
-        self.assertRaises(TypeError, lambda: self.psser % 1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser % psser)
-
-    def test_pow(self):
-        self.assertRaises(TypeError, lambda: self.psser ** "x")
-        self.assertRaises(TypeError, lambda: self.psser**1)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser**psser)
-
-    def test_radd(self):
-        self.assertRaises(TypeError, lambda: "x" + self.psser)
-        self.assertRaises(TypeError, lambda: 1 + self.psser)
-
-    def test_rsub(self):
-        self.assertRaises(TypeError, lambda: "x" - self.psser)
-        self.assertRaises(TypeError, lambda: 1 - self.psser)
-
-    def test_rmul(self):
-        self.assertRaises(TypeError, lambda: "x" * self.psser)
-        self.assertRaises(TypeError, lambda: 2 * self.psser)
-
-    def test_rtruediv(self):
-        self.assertRaises(TypeError, lambda: "x" / self.psser)
-        self.assertRaises(TypeError, lambda: 1 / self.psser)
-
-    def test_rfloordiv(self):
-        self.assertRaises(TypeError, lambda: "x" // self.psser)
-        self.assertRaises(TypeError, lambda: 1 // self.psser)
-
-    def test_rmod(self):
-        self.assertRaises(TypeError, lambda: 1 % self.psser)
-
-    def test_rpow(self):
-        self.assertRaises(TypeError, lambda: "x" ** self.psser)
-        self.assertRaises(TypeError, lambda: 1**self.psser)
-
-    def test_from_to_pandas(self):
-        data = [None, None, None]
-        pser = pd.Series(data)
-        psser = ps.Series(data)
-        self.assert_eq(pser, psser._to_pandas())
-        self.assert_eq(ps.from_pandas(pser), psser)
-
-    def test_isnull(self):
-        self.assert_eq(self.pser.isnull(), self.psser.isnull())
-
-    def test_astype(self):
-        pser = self.pser
-        psser = self.psser
-        self.assert_eq(pser.astype(str), psser.astype(str))
-        self.assert_eq(pser.astype(bool), psser.astype(bool))
-        self.assert_eq(pser.astype("category"), psser.astype("category"))
-        cat_type = CategoricalDtype(categories=[1, 2, 3])
-        self.assert_eq(pser.astype(cat_type), psser.astype(cat_type))
-
-    def test_neg(self):
-        self.assertRaises(TypeError, lambda: -self.psser)
-
-    def test_abs(self):
-        self.assertRaises(TypeError, lambda: abs(self.psser))
-
-    def test_invert(self):
-        self.assertRaises(TypeError, lambda: ~self.psser)
-
-    def test_eq(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser == pser, psser == psser)
-        self.assert_eq(pser == [None, 1, None], psser == [None, 1, None])
-
-    def test_ne(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser != pser, psser != psser)
-
-    def test_lt(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser < pser, psser < psser)
-
-    def test_le(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser <= pser, psser <= psser)
-
-    def test_gt(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser > pser, psser > psser)
-
-    def test_ge(self):
-        pser, psser = self.pser, self.psser
-        self.assert_eq(pser >= pser, psser >= psser)
-
-
-class NullOpsTests(NullOpsTestsMixin, OpsTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.data_type_ops.test_null_ops import *  # noqa: F401
-
-    try:
-        import xmlrunner
-
-        testRunner = xmlrunner.XMLTestRunner(output="target/test-reports", verbosity=2)
-    except ImportError:
-        testRunner = None
-    unittest.main(testRunner=testRunner, verbosity=2)

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/data_type_ops/test_num_arithmetic.py

@@ -1,184 +0,0 @@
-#
-# Licensed to the Apache Software Foundation (ASF) under one or more
-# contributor license agreements.  See the NOTICE file distributed with
-# this work for additional information regarding copyright ownership.
-# The ASF licenses this file to You under the Apache License, Version 2.0
-# (the "License"); you may not use this file except in compliance with
-# the License.  You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-import datetime
-import unittest
-
-import pandas as pd
-import numpy as np
-
-from pyspark import pandas as ps
-from pyspark.pandas.tests.data_type_ops.testing_utils import OpsTestBase
-
-
-class ArithmeticTestsMixin:
-    """Unit tests for arithmetic operations of numeric data types.
-
-    A few test cases are disabled because pandas-on-Spark returns float64 whereas pandas
-    returns float32.
-    The underlying reason is the respective Spark operations return DoubleType always.
-    """
-
-    @property
-    def float_pser(self):
-        return pd.Series([1, 2, 3], dtype=float)
-
-    @property
-    def float_psser(self):
-        return ps.from_pandas(self.float_pser)
-
-    def test_add(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser + pser, psser + psser)
-            self.assert_eq(pser + 1, psser + 1)
-            # self.assert_eq(pser + 0.1, psser + 0.1)
-            self.assert_eq(pser + pser.astype(bool), psser + psser.astype(bool))
-            self.assert_eq(pser + True, psser + True)
-            self.assert_eq(pser + False, psser + False)
-
-            for n_col in self.non_numeric_df_cols:
-                if n_col == "bool":
-                    self.assert_eq(pser + pdf[n_col], psser + psdf[n_col])
-                else:
-                    self.assertRaises(TypeError, lambda: psser + psdf[n_col])
-
-    def test_sub(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser - pser, psser - psser)
-            self.assert_eq(pser - 1, psser - 1)
-            # self.assert_eq(pser - 0.1, psser - 0.1)
-            self.assert_eq(pser - pser.astype(bool), psser - psser.astype(bool))
-            self.assert_eq(pser - True, psser - True)
-            self.assert_eq(pser - False, psser - False)
-
-            for n_col in self.non_numeric_df_cols:
-                if n_col == "bool":
-                    self.assert_eq(pser - pdf[n_col], psser - psdf[n_col])
-                else:
-                    self.assertRaises(TypeError, lambda: psser - psdf[n_col])
-
-    def test_mul(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser * pser, psser * psser)
-            self.assert_eq(pser * pser.astype(bool), psser * psser.astype(bool))
-            self.assert_eq(pser * True, psser * True)
-            self.assert_eq(pser * False, psser * False)
-
-            if psser.dtype in [int, np.int32]:
-                self.assert_eq(pser * pdf["string"], psser * psdf["string"])
-            else:
-                self.assertRaises(TypeError, lambda: psser * psdf["string"])
-
-            self.assert_eq(pser * pdf["bool"], psser * psdf["bool"])
-
-            self.assertRaises(TypeError, lambda: psser * psdf["datetime"])
-            self.assertRaises(TypeError, lambda: psser * psdf["date"])
-            self.assertRaises(TypeError, lambda: psser * psdf["categorical"])
-
-    def test_truediv(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            if psser.dtype in [float, int, np.int32]:
-                self.assert_eq(pser / pser, psser / psser)
-                self.assert_eq(pser / pser.astype(bool), psser / psser.astype(bool))
-                self.assert_eq(pser / True, psser / True)
-                self.assert_eq(pser / False, psser / False)
-
-            for n_col in self.non_numeric_df_cols:
-                if n_col == "bool":
-                    self.assert_eq(pdf["float"] / pdf[n_col], psdf["float"] / psdf[n_col])
-                else:
-                    self.assertRaises(TypeError, lambda: psser / psdf[n_col])
-
-    def test_floordiv(self):
-        pdf, psdf = self.pdf, self.psdf
-        pser, psser = pdf["float"], psdf["float"]
-        self.assert_eq(pser // pser, psser // psser)
-        self.assert_eq(pser // pser.astype(bool), psser // psser.astype(bool))
-        self.assert_eq(pser // True, psser // True)
-        self.assert_eq(pser // False, psser // False)
-
-        for n_col in self.non_numeric_df_cols:
-            if n_col == "bool":
-                self.assert_eq(pdf["float"] // pdf["bool"], psdf["float"] // psdf["bool"])
-            else:
-                for col in self.numeric_df_cols:
-                    psser = psdf[col]
-                    self.assertRaises(TypeError, lambda: psser // psdf[n_col])
-
-    def test_mod(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser % pser, psser % psser)
-            self.assert_eq(pser % pser.astype(bool), psser % psser.astype(bool))
-            self.assert_eq(pser % True, psser % True)
-            if col in ["int", "int32"]:
-                self.assert_eq(
-                    pd.Series([np.nan, np.nan, np.nan], dtype=float, name=col), psser % False
-                )
-            else:
-                self.assert_eq(
-                    pd.Series([np.nan, np.nan, np.nan], dtype=pser.dtype, name=col), psser % False
-                )
-
-            for n_col in self.non_numeric_df_cols:
-                if n_col == "bool":
-                    self.assert_eq(pdf["float"] % pdf[n_col], psdf["float"] % psdf[n_col])
-                else:
-                    self.assertRaises(TypeError, lambda: psser % psdf[n_col])
-
-    def test_pow(self):
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.numeric_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            if col in ["float", "float_w_nan"]:
-                self.assert_eq(pser**pser, psser**psser)
-                self.assert_eq(pser ** pser.astype(bool), psser ** psser.astype(bool))
-                self.assert_eq(pser**True, psser**True)
-                self.assert_eq(pser**False, psser**False)
-                self.assert_eq(pser**1, psser**1)
-                self.assert_eq(pser**0, psser**0)
-
-            for n_col in self.non_numeric_df_cols:
-                if n_col == "bool":
-                    self.assert_eq(pdf["float"] ** pdf[n_col], psdf["float"] ** psdf[n_col])
-                else:
-                    self.assertRaises(TypeError, lambda: psser ** psdf[n_col])
-
-
-class ArithmeticTests(ArithmeticTestsMixin, OpsTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.data_type_ops.test_num_arithmetic import *  # noqa: F401
-
-    try:
-        import xmlrunner
-
-        testRunner = xmlrunner.XMLTestRunner(output="target/test-reports", verbosity=2)
-    except ImportError:
-        testRunner = None
-    unittest.main(testRunner=testRunner, verbosity=2)