snowpark-connect 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/diff_frames_ops/test_basic_slow.py

@@ -1,198 +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
-import numpy as np
-
-from pyspark import pandas as ps
-from pyspark.pandas.config import set_option, reset_option
-from pyspark.testing.pandasutils import PandasOnSparkTestCase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class DiffFramesBasicSlowMixin:
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        set_option("compute.ops_on_diff_frames", True)
-
-    @classmethod
-    def tearDownClass(cls):
-        reset_option("compute.ops_on_diff_frames")
-        super().tearDownClass()
-
-    def test_update(self):
-        pdf = pd.DataFrame({"x": [1, 2, 3], "y": [10, 20, 30]})
-        psdf = ps.from_pandas(pdf)
-
-        pser = pdf.x
-        psser = psdf.x
-        pser.update(pd.Series([4, 5, 6]))
-        psser.update(ps.Series([4, 5, 6]))
-        self.assert_eq(psser.sort_index(), pser.sort_index())
-        self.assert_eq(psdf.sort_index(), pdf.sort_index())
-
-        pser1 = pd.Series([None, 2, 3, 4, 5, 6, 7, 8, None])
-        pser2 = pd.Series([None, 5, None, 3, 2, 1, None, 0, 0])
-        psser1 = ps.from_pandas(pser1)
-        psser2 = ps.from_pandas(pser2)
-
-        pser1.update(pser2)
-        psser1.update(psser2)
-        self.assert_eq(psser1.sort_index(), pser1)
-
-    def test_where(self):
-        pdf1 = pd.DataFrame({"A": [0, 1, 2, 3, 4], "B": [100, 200, 300, 400, 500]})
-        pdf2 = pd.DataFrame({"A": [0, -1, -2, -3, -4], "B": [-100, -200, -300, -400, -500]})
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.where(pdf2 > 100), psdf1.where(psdf2 > 100).sort_index())
-
-        pdf1 = pd.DataFrame({"A": [-1, -2, -3, -4, -5], "B": [-100, -200, -300, -400, -500]})
-        pdf2 = pd.DataFrame({"A": [-10, -20, -30, -40, -50], "B": [-5, -4, -3, -2, -1]})
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.where(pdf2 < -250), psdf1.where(psdf2 < -250).sort_index())
-
-        # multi-index columns
-        pdf1 = pd.DataFrame({("X", "A"): [0, 1, 2, 3, 4], ("X", "B"): [100, 200, 300, 400, 500]})
-        pdf2 = pd.DataFrame(
-            {("X", "A"): [0, -1, -2, -3, -4], ("X", "B"): [-100, -200, -300, -400, -500]}
-        )
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.where(pdf2 > 100), psdf1.where(psdf2 > 100).sort_index())
-
-    def test_mask(self):
-        pdf1 = pd.DataFrame({"A": [0, 1, 2, 3, 4], "B": [100, 200, 300, 400, 500]})
-        pdf2 = pd.DataFrame({"A": [0, -1, -2, -3, -4], "B": [-100, -200, -300, -400, -500]})
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.mask(pdf2 < 100), psdf1.mask(psdf2 < 100).sort_index())
-
-        pdf1 = pd.DataFrame({"A": [-1, -2, -3, -4, -5], "B": [-100, -200, -300, -400, -500]})
-        pdf2 = pd.DataFrame({"A": [-10, -20, -30, -40, -50], "B": [-5, -4, -3, -2, -1]})
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.mask(pdf2 > -250), psdf1.mask(psdf2 > -250).sort_index())
-
-        # multi-index columns
-        pdf1 = pd.DataFrame({("X", "A"): [0, 1, 2, 3, 4], ("X", "B"): [100, 200, 300, 400, 500]})
-        pdf2 = pd.DataFrame(
-            {("X", "A"): [0, -1, -2, -3, -4], ("X", "B"): [-100, -200, -300, -400, -500]}
-        )
-        psdf1 = ps.from_pandas(pdf1)
-        psdf2 = ps.from_pandas(pdf2)
-
-        self.assert_eq(pdf1.mask(pdf2 < 100), psdf1.mask(psdf2 < 100).sort_index())
-
-    def test_to_series_comparison(self):
-        psidx1 = ps.Index([1, 2, 3, 4, 5])
-        psidx2 = ps.Index([1, 2, 3, 4, 5])
-
-        self.assert_eq((psidx1.to_series() == psidx2.to_series()).all(), True)
-
-        psidx1.name = "koalas"
-        psidx2.name = "koalas"
-
-        self.assert_eq((psidx1.to_series() == psidx2.to_series()).all(), True)
-
-    def test_pow_and_rpow(self):
-        pser = pd.Series([1, 2, np.nan])
-        psser = ps.from_pandas(pser)
-        pser_other = pd.Series([np.nan, 2, 3])
-        psser_other = ps.from_pandas(pser_other)
-
-        self.assert_eq(pser.pow(pser_other), psser.pow(psser_other).sort_index())
-        self.assert_eq(pser**pser_other, (psser**psser_other).sort_index())
-        self.assert_eq(pser.rpow(pser_other), psser.rpow(psser_other).sort_index())
-
-    def test_shift(self):
-        pdf = pd.DataFrame(
-            {
-                "Col1": [10, 20, 15, 30, 45],
-                "Col2": [13, 23, 18, 33, 48],
-                "Col3": [17, 27, 22, 37, 52],
-            },
-            index=np.random.rand(5),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(
-            pdf.shift().loc[pdf["Col1"] == 20].astype(int), psdf.shift().loc[psdf["Col1"] == 20]
-        )
-        self.assert_eq(
-            pdf["Col2"].shift().loc[pdf["Col1"] == 20].astype(int),
-            psdf["Col2"].shift().loc[psdf["Col1"] == 20],
-        )
-
-    def test_diff(self):
-        pdf = pd.DataFrame(
-            {
-                "Col1": [10, 20, 15, 30, 45],
-                "Col2": [13, 23, 18, 33, 48],
-                "Col3": [17, 27, 22, 37, 52],
-            },
-            index=np.random.rand(5),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(
-            pdf.diff().loc[pdf["Col1"] == 20].astype(int), psdf.diff().loc[psdf["Col1"] == 20]
-        )
-        self.assert_eq(
-            pdf["Col2"].diff().loc[pdf["Col1"] == 20].astype(int),
-            psdf["Col2"].diff().loc[psdf["Col1"] == 20],
-        )
-
-    def test_rank(self):
-        pdf = pd.DataFrame(
-            {
-                "Col1": [10, 20, 15, 30, 45],
-                "Col2": [13, 23, 18, 33, 48],
-                "Col3": [17, 27, 22, 37, 52],
-            },
-            index=np.random.rand(5),
-        )
-        psdf = ps.from_pandas(pdf)
-
-        self.assert_eq(pdf.rank().loc[pdf["Col1"] == 20], psdf.rank().loc[psdf["Col1"] == 20])
-        self.assert_eq(
-            pdf["Col2"].rank().loc[pdf["Col1"] == 20], psdf["Col2"].rank().loc[psdf["Col1"] == 20]
-        )
-
-
-class DiffFramesBasicSlowTests(DiffFramesBasicSlowMixin, PandasOnSparkTestCase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.diff_frames_ops.test_basic_slow 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/diff_frames_ops/test_cov_corrwith.py

@@ -1,181 +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.
-#
-from distutils.version import LooseVersion
-
-import pandas as pd
-import numpy as np
-
-from pyspark import pandas as ps
-from pyspark.pandas.config import set_option, reset_option
-from pyspark.testing.pandasutils import PandasOnSparkTestCase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class DiffFramesCovCorrWithMixin:
-    @property
-    def pdf1(self):
-        return pd.DataFrame(
-            {"a": [1, 2, 3, 4, 5, 6, 7, 8, 9], "b": [4, 5, 6, 3, 2, 1, 0, 0, 0]},
-            index=[0, 1, 3, 5, 6, 8, 9, 10, 11],
-        )
-
-    @property
-    def pdf2(self):
-        return pd.DataFrame(
-            {"a": [9, 8, 7, 6, 5, 4, 3, 2, 1], "b": [0, 0, 0, 4, 5, 6, 1, 2, 3]},
-            index=list(range(9)),
-        )
-
-    @property
-    def pdf3(self):
-        return pd.DataFrame(
-            {"b": [1, 1, 1, 1, 1, 1, 1, 1, 1], "c": [1, 1, 1, 1, 1, 1, 1, 1, 1]},
-            index=list(range(9)),
-        )
-
-    @property
-    def pdf4(self):
-        return pd.DataFrame(
-            {"e": [2, 2, 2, 2, 2, 2, 2, 2, 2], "f": [2, 2, 2, 2, 2, 2, 2, 2, 2]},
-            index=list(range(9)),
-        )
-
-    @property
-    def psdf1(self):
-        return ps.from_pandas(self.pdf1)
-
-    @property
-    def psdf2(self):
-        return ps.from_pandas(self.pdf2)
-
-    @property
-    def psdf3(self):
-        return ps.from_pandas(self.pdf3)
-
-    @property
-    def psdf4(self):
-        return ps.from_pandas(self.pdf4)
-
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        set_option("compute.ops_on_diff_frames", True)
-
-    @classmethod
-    def tearDownClass(cls):
-        reset_option("compute.ops_on_diff_frames")
-        super().tearDownClass()
-
-    def test_cov(self):
-        pser1 = pd.Series([0.90010907, 0.13484424, 0.62036035], index=[0, 1, 2])
-        pser2 = pd.Series([0.12528585, 0.26962463, 0.51111198], index=[1, 2, 3])
-        self._test_cov(pser1, pser2)
-
-        pser1 = pd.Series([0.90010907, 0.13484424, 0.62036035], index=[0, 1, 2])
-        pser2 = pd.Series([0.12528585, 0.26962463, 0.51111198, 0.32076008], index=[1, 2, 3, 4])
-        self._test_cov(pser1, pser2)
-
-        pser1 = pd.Series([0.90010907, 0.13484424, 0.62036035, 0.32076008], index=[0, 1, 2, 3])
-        pser2 = pd.Series([0.12528585, 0.26962463], index=[1, 2])
-        self._test_cov(pser1, pser2)
-
-        psser1 = ps.from_pandas(pser1)
-        with self.assertRaisesRegex(TypeError, "unsupported type: <class 'list'>"):
-            psser1.cov([0.12528585, 0.26962463, 0.51111198])
-        with self.assertRaisesRegex(
-            TypeError, "unsupported type: <class 'pandas.core.series.Series'>"
-        ):
-            psser1.cov(pser2)
-
-    def _test_cov(self, pser1, pser2):
-        psser1 = ps.from_pandas(pser1)
-        psser2 = ps.from_pandas(pser2)
-
-        pcov = pser1.cov(pser2)
-        pscov = psser1.cov(psser2)
-        self.assert_eq(pcov, pscov, almost=True)
-
-        pcov = pser1.cov(pser2, min_periods=2)
-        pscov = psser1.cov(psser2, min_periods=2)
-        self.assert_eq(pcov, pscov, almost=True)
-
-        pcov = pser1.cov(pser2, min_periods=3)
-        pscov = psser1.cov(psser2, min_periods=3)
-        self.assert_eq(pcov, pscov, almost=True)
-
-    def test_corrwith(self):
-        df1 = ps.DataFrame({"A": [1, np.nan, 7, 8], "X": [5, 8, np.nan, 3], "C": [10, 4, 9, 3]})
-        df2 = ps.DataFrame({"A": [5, 3, 6, 4], "B": [11, 2, 4, 3], "C": [4, 3, 8, np.nan]})
-        self._test_corrwith(df1, df2)
-        self._test_corrwith((df1 + 1), df2.B)
-        self._test_corrwith((df1 + 1), (df2.B + 2))
-
-        # There was a regression in pandas 1.5.0, and fixed in pandas 1.5.1.
-        # Therefore, we only test the pandas 1.5.0 in different way.
-        # See https://github.com/pandas-dev/pandas/issues/49141 for the reported issue,
-        # and https://github.com/pandas-dev/pandas/pull/46174 for the initial PR that causes.
-        df_bool = ps.DataFrame({"A": [True, True, False, False], "B": [True, False, False, True]})
-        ser_bool = ps.Series([True, True, False, True])
-        if LooseVersion(pd.__version__) == LooseVersion("1.5.0"):
-            expected = ps.Series([0.5773502691896257, 0.5773502691896257], index=["B", "A"])
-            self.assert_eq(df_bool.corrwith(ser_bool), expected, almost=True)
-        else:
-            self._test_corrwith(df_bool, ser_bool)
-
-        self._test_corrwith(self.psdf1, self.psdf1)
-        self._test_corrwith(self.psdf1, self.psdf2)
-        self._test_corrwith(self.psdf2, self.psdf3)
-        self._test_corrwith(self.psdf3, self.psdf4)
-
-        self._test_corrwith(self.psdf1, self.psdf1.a)
-        # There was a regression in pandas 1.5.0, and fixed in pandas 1.5.1.
-        # Therefore, we only test the pandas 1.5.0 in different way.
-        # See https://github.com/pandas-dev/pandas/issues/49141 for the reported issue,
-        # and https://github.com/pandas-dev/pandas/pull/46174 for the initial PR that causes.
-        if LooseVersion(pd.__version__) == LooseVersion("1.5.0"):
-            expected = ps.Series([-0.08827348295047496, 0.4413674147523748], index=["b", "a"])
-            self.assert_eq(self.psdf1.corrwith(self.psdf2.b), expected, almost=True)
-        else:
-            self._test_corrwith(self.psdf1, self.psdf2.b)
-
-        self._test_corrwith(self.psdf2, self.psdf3.c)
-        self._test_corrwith(self.psdf3, self.psdf4.f)
-
-    def _test_corrwith(self, psdf, psobj):
-        pdf = psdf._to_pandas()
-        pobj = psobj._to_pandas()
-        for drop in [True, False]:
-            p_corr = pdf.corrwith(pobj, drop=drop)
-            ps_corr = psdf.corrwith(psobj, drop=drop)
-            self.assert_eq(p_corr.sort_index(), ps_corr.sort_index(), almost=True)
-
-
-class DiffFramesCovCorrWithTests(DiffFramesCovCorrWithMixin, PandasOnSparkTestCase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.diff_frames_ops.test_cov_corrwith 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/diff_frames_ops/test_dot_frame.py

@@ -1,103 +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 pyspark import pandas as ps
-from pyspark.pandas.config import set_option, reset_option
-from pyspark.testing.pandasutils import PandasOnSparkTestCase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class DiffFramesDotFrameMixin:
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        set_option("compute.ops_on_diff_frames", True)
-
-    @classmethod
-    def tearDownClass(cls):
-        reset_option("compute.ops_on_diff_frames")
-        super().tearDownClass()
-
-    def test_frame_dot(self):
-        pdf = pd.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]])
-        psdf = ps.from_pandas(pdf)
-
-        pser = pd.Series([1, 1, 2, 1])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # Index reorder
-        pser = pser.reindex([1, 0, 2, 3])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # ser with name
-        pser.name = "ser"
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # df with MultiIndex as column (ser with MultiIndex)
-        arrays = [[1, 1, 2, 2], ["red", "blue", "red", "blue"]]
-        pidx = pd.MultiIndex.from_arrays(arrays, names=("number", "color"))
-        pser = pd.Series([1, 1, 2, 1], index=pidx)
-        pdf = pd.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]], columns=pidx)
-        psdf = ps.from_pandas(pdf)
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # df with Index as column (ser with Index)
-        pidx = pd.Index([1, 2, 3, 4], name="number")
-        pser = pd.Series([1, 1, 2, 1], index=pidx)
-        pdf = pd.DataFrame([[0, 1, -2, -1], [1, 1, 1, 1]], columns=pidx)
-        psdf = ps.from_pandas(pdf)
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # df with Index
-        pdf.index = pd.Index(["x", "y"], name="char")
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        # df with MultiIndex
-        pdf.index = pd.MultiIndex.from_arrays([[1, 1], ["red", "blue"]], names=("number", "color"))
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf.dot(psser), pdf.dot(pser))
-
-        pdf = pd.DataFrame([[1, 2], [3, 4]])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psdf.dot(psdf[0]), pdf.dot(pdf[0]))
-        self.assert_eq(psdf.dot(psdf[0] * 10), pdf.dot(pdf[0] * 10))
-        self.assert_eq((psdf + 1).dot(psdf[0] * 10), (pdf + 1).dot(pdf[0] * 10))
-
-
-class DiffFramesDotFrameTests(DiffFramesDotFrameMixin, PandasOnSparkTestCase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.diff_frames_ops.test_dot_frame 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/diff_frames_ops/test_dot_series.py

@@ -1,141 +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 pyspark import pandas as ps
-from pyspark.pandas.config import set_option, reset_option
-from pyspark.testing.pandasutils import PandasOnSparkTestCase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class DiffFramesDotSeriesMixin:
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        set_option("compute.ops_on_diff_frames", True)
-
-    @classmethod
-    def tearDownClass(cls):
-        reset_option("compute.ops_on_diff_frames")
-        super().tearDownClass()
-
-    def test_series_dot(self):
-        pser = pd.Series([90, 91, 85], index=[2, 4, 1])
-        psser = ps.from_pandas(pser)
-        pser_other = pd.Series([90, 91, 85], index=[2, 4, 1])
-        psser_other = ps.from_pandas(pser_other)
-
-        self.assert_eq(psser.dot(psser_other), pser.dot(pser_other))
-
-        psser_other = ps.Series([90, 91, 85], index=[1, 2, 4])
-        pser_other = pd.Series([90, 91, 85], index=[1, 2, 4])
-
-        self.assert_eq(psser.dot(psser_other), pser.dot(pser_other))
-
-        # length of index is different
-        psser_other = ps.Series([90, 91, 85, 100], index=[2, 4, 1, 0])
-        with self.assertRaisesRegex(ValueError, "matrices are not aligned"):
-            psser.dot(psser_other)
-
-        # for MultiIndex
-        midx = pd.MultiIndex(
-            [["lama", "cow", "falcon"], ["speed", "weight", "length"]],
-            [[0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 1, 2, 0, 1, 2, 0, 1, 2]],
-        )
-        pser = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3], index=midx)
-        psser = ps.from_pandas(pser)
-        pser_other = pd.Series([-450, 20, 12, -30, -250, 15, -320, 100, 3], index=midx)
-        psser_other = ps.from_pandas(pser_other)
-        self.assert_eq(psser.dot(psser_other), pser.dot(pser_other))
-
-        pser = pd.Series([0, 1, 2, 3])
-        psser = ps.from_pandas(pser)
-
-        # DataFrame "other" without Index/MultiIndex as columns
-        pdf = pd.DataFrame([[0, 1], [-2, 3], [4, -5], [6, 7]])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-
-        # DataFrame "other" with Index as columns
-        pdf.columns = pd.Index(["x", "y"])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-        pdf.columns = pd.Index(["x", "y"], name="cols_name")
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-
-        pdf = pdf.reindex([1, 0, 2, 3])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-
-        # DataFrame "other" with MultiIndex as columns
-        pdf.columns = pd.MultiIndex.from_tuples([("a", "x"), ("b", "y")])
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-        pdf.columns = pd.MultiIndex.from_tuples(
-            [("a", "x"), ("b", "y")], names=["cols_name1", "cols_name2"]
-        )
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-
-        psser = ps.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}).b
-        pser = psser._to_pandas()
-        psdf = ps.DataFrame({"c": [7, 8, 9]})
-        pdf = psdf._to_pandas()
-        self.assert_eq(psser.dot(psdf), pser.dot(pdf))
-
-        # SPARK-36968: ps.Series.dot raise "matrices are not aligned" if index is not same
-        pser = pd.Series([90, 91, 85], index=[0, 1, 2])
-        psser = ps.from_pandas(pser)
-        pser_other = pd.Series([90, 91, 85], index=[0, 1, 3])
-        psser_other = ps.from_pandas(pser_other)
-        pser_other2 = pd.Series([90, 91, 85, 100], index=[0, 1, 3, 5])
-        psser_other2 = ps.from_pandas(pser_other2)
-
-        with self.assertRaisesRegex(ValueError, "matrices are not aligned"):
-            psser.dot(psser_other)
-
-        with ps.option_context("compute.eager_check", False), self.assertRaisesRegex(
-            ValueError, "matrices are not aligned"
-        ):
-            psser.dot(psser_other2)
-
-        with ps.option_context("compute.eager_check", True), self.assertRaisesRegex(
-            ValueError, "matrices are not aligned"
-        ):
-            psser.dot(psser_other)
-
-        with ps.option_context("compute.eager_check", False):
-            self.assert_eq(psser.dot(psser_other), 16381)
-
-
-class DiffFramesDotSeriesTests(DiffFramesDotSeriesMixin, PandasOnSparkTestCase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.diff_frames_ops.test_dot_series 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)