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_complex_ops.py

@@ -1,368 +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 decimal
-import datetime
-
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.pandas.tests.data_type_ops.testing_utils import OpsTestBase
-
-
-class ComplexOpsTestsMixin:
-    @property
-    def pser(self):
-        return pd.Series([[1, 2, 3]])
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    @property
-    def numeric_array_pdf(self):
-        psers = {
-            "int": pd.Series([[1, 2, 3]]),
-            "float": pd.Series([[0.1, 0.2, 0.3]]),
-            "decimal": pd.Series([[decimal.Decimal(1), decimal.Decimal(2), decimal.Decimal(3)]]),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def numeric_array_psdf(self):
-        return ps.from_pandas(self.numeric_array_pdf)
-
-    @property
-    def numeric_array_df_cols(self):
-        return self.numeric_array_pdf.columns
-
-    @property
-    def non_numeric_array_pdf(self):
-        psers = {
-            "string": pd.Series([["x", "y", "z"]]),
-            "date": pd.Series(
-                [[datetime.date(1994, 1, 1), datetime.date(1994, 1, 2), datetime.date(1994, 1, 3)]]
-            ),
-            "bool": pd.Series([[True, True, False]]),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def non_numeric_array_psdf(self):
-        return ps.from_pandas(self.non_numeric_array_pdf)
-
-    @property
-    def non_numeric_array_df_cols(self):
-        return self.non_numeric_array_pdf.columns
-
-    @property
-    def array_pdf(self):
-        return pd.concat([self.numeric_array_pdf, self.non_numeric_array_pdf], axis=1)
-
-    @property
-    def array_psdf(self):
-        return ps.from_pandas(self.array_pdf)
-
-    @property
-    def array_df_cols(self):
-        return self.array_pdf.columns
-
-    @property
-    def complex_pdf(self):
-        psers = {
-            "this_array": self.pser,
-            "that_array": pd.Series([[2, 3, 4]]),
-            "this_struct": pd.Series([("x", 1)]),
-            "that_struct": pd.Series([("a", 2)]),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def complex_psdf(self):
-        pssers = {
-            "this_array": self.psser,
-            "that_array": ps.Series([[2, 3, 4]]),
-            "this_struct": ps.Index([("x", 1)]).to_series().reset_index(drop=True),
-            "that_struct": ps.Index([("a", 2)]).to_series().reset_index(drop=True),
-        }
-        return ps.concat(pssers, axis=1)
-
-    def test_add(self):
-        pdf, psdf = self.array_pdf, self.array_psdf
-        for col in self.array_df_cols:
-            self.assert_eq(pdf[col] + pdf[col], psdf[col] + psdf[col])
-
-        # Numeric array + Numeric array
-        for col in self.numeric_array_df_cols:
-            pser1, psser1 = pdf[col], psdf[col]
-            for other_col in self.numeric_array_df_cols:
-                pser2, psser2 = pdf[other_col], psdf[other_col]
-                self.assert_eq((pser1 + pser2).sort_values(), (psser1 + psser2).sort_values())
-
-        # Non-numeric array + Non-numeric array
-        self.assertRaises(
-            TypeError,
-            lambda: psdf["string"] + psdf["bool"],
-        )
-        self.assertRaises(
-            TypeError,
-            lambda: psdf["string"] + psdf["date"],
-        )
-        self.assertRaises(
-            TypeError,
-            lambda: psdf["bool"] + psdf["date"],
-        )
-
-        for col in self.non_numeric_array_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser + pser, psser + psser)
-
-        # Numeric array + Non-numeric array
-        for numeric_col in self.numeric_array_df_cols:
-            for non_numeric_col in self.non_numeric_array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[numeric_col] + psdf[non_numeric_col])
-
-    def test_sub(self):
-        self.assertRaises(TypeError, lambda: self.psser - "x")
-        self.assertRaises(TypeError, lambda: self.psser - 1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] - psdf[other_col])
-
-    def test_mul(self):
-        self.assertRaises(TypeError, lambda: self.psser * "x")
-        self.assertRaises(TypeError, lambda: self.psser * 1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] * psdf[other_col])
-
-    def test_truediv(self):
-        self.assertRaises(TypeError, lambda: self.psser / "x")
-        self.assertRaises(TypeError, lambda: self.psser / 1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] / psdf[other_col])
-
-    def test_floordiv(self):
-        self.assertRaises(TypeError, lambda: self.psser // "x")
-        self.assertRaises(TypeError, lambda: self.psser // 1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] // psdf[other_col])
-
-    def test_mod(self):
-        self.assertRaises(TypeError, lambda: self.psser % "x")
-        self.assertRaises(TypeError, lambda: self.psser % 1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] % psdf[other_col])
-
-    def test_pow(self):
-        self.assertRaises(TypeError, lambda: self.psser ** "x")
-        self.assertRaises(TypeError, lambda: self.psser**1)
-
-        psdf = self.array_psdf
-        for col in self.array_df_cols:
-            for other_col in self.array_df_cols:
-                self.assertRaises(TypeError, lambda: psdf[col] ** psdf[other_col])
-
-    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_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):
-        pdf, psdf = self.array_pdf, self.array_psdf
-        for col in self.array_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser, psser._to_pandas())
-            self.assert_eq(ps.from_pandas(pser), psser)
-
-    def test_isnull(self):
-        pdf, psdf = self.array_pdf, self.array_psdf
-        for col in self.array_df_cols:
-            pser, psser = pdf[col], psdf[col]
-            self.assert_eq(pser.isnull(), psser.isnull())
-
-    def test_astype(self):
-        self.assert_eq(self.pser.astype(str), self.psser.astype(str))
-
-    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.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] == pdf["that_array"], psdf["this_array"] == psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] == pdf["that_struct"], psdf["this_struct"] == psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] == pdf["this_array"], psdf["this_array"] == psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] == pdf["this_struct"], psdf["this_struct"] == psdf["this_struct"]
-        )
-
-    def test_ne(self):
-        pdf, psdf = self.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] != pdf["that_array"], psdf["this_array"] != psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] != pdf["that_struct"], psdf["this_struct"] != psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] != pdf["this_array"], psdf["this_array"] != psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] != pdf["this_struct"], psdf["this_struct"] != psdf["this_struct"]
-        )
-
-    def test_lt(self):
-        pdf, psdf = self.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] < pdf["that_array"], psdf["this_array"] < psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] < pdf["that_struct"], psdf["this_struct"] < psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] < pdf["this_array"], psdf["this_array"] < psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] < pdf["this_struct"], psdf["this_struct"] < psdf["this_struct"]
-        )
-
-    def test_le(self):
-        pdf, psdf = self.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] <= pdf["that_array"], psdf["this_array"] <= psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] <= pdf["that_struct"], psdf["this_struct"] <= psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] <= pdf["this_array"], psdf["this_array"] <= psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] <= pdf["this_struct"], psdf["this_struct"] <= psdf["this_struct"]
-        )
-
-    def test_gt(self):
-        pdf, psdf = self.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] > pdf["that_array"], psdf["this_array"] > psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] > pdf["that_struct"], psdf["this_struct"] > psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] > pdf["this_array"], psdf["this_array"] > psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] > pdf["this_struct"], psdf["this_struct"] > psdf["this_struct"]
-        )
-
-    def test_ge(self):
-        pdf, psdf = self.complex_pdf, self.complex_pdf
-        self.assert_eq(
-            pdf["this_array"] >= pdf["that_array"], psdf["this_array"] >= psdf["that_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] >= pdf["that_struct"], psdf["this_struct"] >= psdf["that_struct"]
-        )
-        self.assert_eq(
-            pdf["this_array"] >= pdf["this_array"], psdf["this_array"] >= psdf["this_array"]
-        )
-        self.assert_eq(
-            pdf["this_struct"] >= pdf["this_struct"], psdf["this_struct"] >= psdf["this_struct"]
-        )
-
-
-class ComplexOpsTests(ComplexOpsTestsMixin, OpsTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.data_type_ops.test_complex_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_date_ops.py

@@ -1,257 +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
-from distutils.version import LooseVersion
-
-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 DateOpsTestsMixin:
-    @property
-    def pser(self):
-        return pd.Series(
-            [datetime.date(1994, 1, 31), datetime.date(1994, 2, 1), datetime.date(1994, 2, 2)]
-        )
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    @property
-    def date_pdf(self):
-        psers = {
-            "this": self.pser,
-            "that": pd.Series(
-                [datetime.date(2000, 1, 31), datetime.date(1994, 3, 1), datetime.date(1990, 2, 2)]
-            ),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def date_psdf(self):
-        return ps.from_pandas(self.date_pdf)
-
-    @property
-    def some_date(self):
-        return datetime.date(1994, 1, 1)
-
-    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_date)
-
-        for psser in self.pssers:
-            self.assertRaises(TypeError, lambda: self.psser + psser)
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43571): Enable DateOpsTests.test_sub for pandas 2.0.0.",
-    )
-    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_date).dt.days,
-            self.psser - self.some_date,
-        )
-        pdf, psdf = self.pdf, self.psdf
-        for col in self.df_cols:
-            if col == "date":
-                self.assert_eq((pdf["date"] - pdf[col]).dt.days, psdf["date"] - psdf[col])
-            else:
-                self.assertRaises(TypeError, lambda: psdf["date"] - psdf[col])
-        pdf, psdf = self.date_pdf, self.date_psdf
-        self.assert_eq((pdf["this"] - pdf["that"]).dt.days, psdf["this"] - psdf["that"])
-
-    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_date)
-
-        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_date)
-
-        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_date)
-
-        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_date)
-
-        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_date)
-
-        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_date + self.psser)
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43570): Enable DateOpsTests.test_rsub for pandas 2.0.0.",
-    )
-    def test_rsub(self):
-        self.assertRaises(TypeError, lambda: "x" - self.psser)
-        self.assertRaises(TypeError, lambda: 1 - self.psser)
-        self.assert_eq(
-            (self.some_date - self.pser).dt.days,
-            self.some_date - 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_date * 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_date / 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_date // self.psser)
-
-    def test_rmod(self):
-        self.assertRaises(TypeError, lambda: 1 % self.psser)
-        self.assertRaises(TypeError, lambda: self.some_date % 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_date**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 = [datetime.date(1994, 1, 31), datetime.date(1994, 2, 1), datetime.date(1994, 2, 2)]
-        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))
-        cat_type = CategoricalDtype(categories=["a", "b", "c"])
-        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):
-        pdf, psdf = self.date_pdf, self.date_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.date_pdf, self.date_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.date_pdf, self.date_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.date_pdf, self.date_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.date_pdf, self.date_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.date_pdf, self.date_psdf
-        self.assert_eq(pdf["this"] >= pdf["that"], psdf["this"] >= psdf["that"])
-        self.assert_eq(pdf["this"] >= pdf["this"], psdf["this"] >= psdf["this"])
-
-
-class DateOpsTests(DateOpsTestsMixin, OpsTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.data_type_ops.test_date_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)