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

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/series/test_all_any.py

@@ -1,105 +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 unittest
-
-import numpy as np
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.testing.pandasutils import ComparisonTestBase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class SeriesAllAnyMixin:
-    @property
-    def pser(self):
-        return pd.Series([1, 2, 3, 4, 5, 6, 7], name="x")
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    def test_all(self):
-        for pser in [
-            pd.Series([True, True], name="x"),
-            pd.Series([True, False], name="x"),
-            pd.Series([0, 1], name="x"),
-            pd.Series([1, 2, 3], name="x"),
-            pd.Series([np.nan, 0, 1], name="x"),
-            pd.Series([np.nan, 1, 2, 3], name="x"),
-            pd.Series([True, True, None], name="x"),
-            pd.Series([True, False, None], name="x"),
-            pd.Series([], name="x"),
-            pd.Series([np.nan], name="x"),
-            pd.Series([np.nan, np.nan], name="x"),
-            pd.Series([None], name="x"),
-            pd.Series([None, None], name="x"),
-        ]:
-            psser = ps.from_pandas(pser)
-            self.assert_eq(psser.all(), pser.all())
-            self.assert_eq(psser.all(skipna=False), pser.all(skipna=False))
-            self.assert_eq(psser.all(skipna=True), pser.all(skipna=True))
-
-        pser = pd.Series([1, 2, 3, 4], name="x")
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq((psser % 2 == 0).all(), (pser % 2 == 0).all())
-
-        with self.assertRaisesRegex(
-            NotImplementedError, 'axis should be either 0 or "index" currently.'
-        ):
-            psser.all(axis=1)
-
-    def test_any(self):
-        for pser in [
-            pd.Series([False, False], name="x"),
-            pd.Series([True, False], name="x"),
-            pd.Series([0, 1], name="x"),
-            pd.Series([1, 2, 3], name="x"),
-            pd.Series([True, True, None], name="x"),
-            pd.Series([True, False, None], name="x"),
-            pd.Series([], name="x"),
-            pd.Series([np.nan], name="x"),
-        ]:
-            psser = ps.from_pandas(pser)
-            self.assert_eq(psser.any(), pser.any())
-
-        pser = pd.Series([1, 2, 3, 4], name="x")
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq((psser % 2 == 0).any(), (pser % 2 == 0).any())
-
-        with self.assertRaisesRegex(
-            NotImplementedError, 'axis should be either 0 or "index" currently.'
-        ):
-            psser.any(axis=1)
-
-
-class SeriesAllAnyTests(SeriesAllAnyMixin, ComparisonTestBase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.series.test_all_any 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/series/test_arg_ops.py

@@ -1,197 +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 unittest
-
-import numpy as np
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.testing.pandasutils import ComparisonTestBase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class SeriesArgOpsMixin:
-    @property
-    def pser(self):
-        return pd.Series([1, 2, 3, 4, 5, 6, 7], name="x")
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    def test_argsort(self):
-        # Without null values
-        pser = pd.Series([0, -100, 50, 100, 20], index=["A", "B", "C", "D", "E"])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # MultiIndex
-        pser.index = pd.MultiIndex.from_tuples(
-            [("a", "v"), ("b", "w"), ("c", "x"), ("d", "y"), ("e", "z")]
-        )
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # With name
-        pser.name = "Koalas"
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # Series from Index
-        pidx = pd.Index([4.0, -6.0, 2.0, -100.0, 11.0, 20.0, 1.0, -99.0])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(
-            pidx.to_series().argsort().sort_index(), psidx.to_series().argsort().sort_index()
-        )
-        self.assert_eq(
-            (-pidx.to_series()).argsort().sort_index(), (-psidx.to_series()).argsort().sort_index()
-        )
-
-        # Series from Index with name
-        pidx.name = "Koalas"
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(
-            pidx.to_series().argsort().sort_index(), psidx.to_series().argsort().sort_index()
-        )
-        self.assert_eq(
-            (-pidx.to_series()).argsort().sort_index(), (-psidx.to_series()).argsort().sort_index()
-        )
-
-        # Series from DataFrame
-        pdf = pd.DataFrame({"A": [4.0, -6.0, 2.0, np.nan, -100.0, 11.0, 20.0, np.nan, 1.0, -99.0]})
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(pdf.A.argsort().sort_index(), psdf.A.argsort().sort_index())
-        self.assert_eq((-pdf.A).argsort().sort_index(), (-psdf.A).argsort().sort_index())
-
-        # With null values
-        pser = pd.Series([0, -100, np.nan, 100, np.nan], index=["A", "B", "C", "D", "E"])
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # MultiIndex with null values
-        pser.index = pd.MultiIndex.from_tuples(
-            [("a", "v"), ("b", "w"), ("c", "x"), ("d", "y"), ("e", "z")]
-        )
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # With name with null values
-        pser.name = "Koalas"
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argsort().sort_index(), psser.argsort().sort_index())
-        self.assert_eq((-pser).argsort().sort_index(), (-psser).argsort().sort_index())
-
-        # Series from Index with null values
-        pidx = pd.Index([4.0, -6.0, 2.0, np.nan, -100.0, 11.0, 20.0, np.nan, 1.0, -99.0])
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(
-            pidx.to_series().argsort().sort_index(), psidx.to_series().argsort().sort_index()
-        )
-        self.assert_eq(
-            (-pidx.to_series()).argsort().sort_index(), (-psidx.to_series()).argsort().sort_index()
-        )
-
-        # Series from Index with name with null values
-        pidx.name = "Koalas"
-        psidx = ps.from_pandas(pidx)
-        self.assert_eq(
-            pidx.to_series().argsort().sort_index(), psidx.to_series().argsort().sort_index()
-        )
-        self.assert_eq(
-            (-pidx.to_series()).argsort().sort_index(), (-psidx.to_series()).argsort().sort_index()
-        )
-
-        # Series from DataFrame with null values
-        pdf = pd.DataFrame({"A": [4.0, -6.0, 2.0, np.nan, -100.0, 11.0, 20.0, np.nan, 1.0, -99.0]})
-        psdf = ps.from_pandas(pdf)
-        self.assert_eq(pdf.A.argsort().sort_index(), psdf.A.argsort().sort_index())
-        self.assert_eq((-pdf.A).argsort().sort_index(), (-psdf.A).argsort().sort_index())
-
-    def test_argmin_argmax(self):
-        pser = pd.Series(
-            {
-                "Corn Flakes": 100.0,
-                "Almond Delight": 110.0,
-                "Cinnamon Toast Crunch": 120.0,
-                "Cocoa Puff": 110.0,
-                "Expensive Flakes": 120.0,
-                "Cheap Flakes": 100.0,
-            },
-            name="Koalas",
-        )
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argmin(), psser.argmin())
-        self.assert_eq(pser.argmax(), psser.argmax())
-        self.assert_eq(pser.argmin(skipna=False), psser.argmin(skipna=False))
-        self.assert_eq(pser.argmax(skipna=False), psser.argmax(skipna=False))
-        self.assert_eq(pser.argmax(skipna=False), psser.argmax(skipna=False))
-        self.assert_eq((pser + 1).argmax(skipna=False), (psser + 1).argmax(skipna=False))
-        self.assert_eq(pser.argmin(skipna=False), psser.argmin(skipna=False))
-        self.assert_eq((pser + 1).argmin(skipna=False), (psser + 1).argmin(skipna=False))
-
-        # MultiIndex
-        pser.index = pd.MultiIndex.from_tuples(
-            [("a", "t"), ("b", "u"), ("c", "v"), ("d", "w"), ("e", "x"), ("f", "u")]
-        )
-        psser = ps.from_pandas(pser)
-        self.assert_eq(pser.argmin(), psser.argmin())
-        self.assert_eq(pser.argmax(), psser.argmax())
-        self.assert_eq(pser.argmax(skipna=False), psser.argmax(skipna=False))
-
-        pser2 = pd.Series([np.NaN, 1.0, 2.0, np.NaN])
-        psser2 = ps.from_pandas(pser2)
-        self.assert_eq(pser2.argmin(), psser2.argmin())
-        self.assert_eq(pser2.argmax(), psser2.argmax())
-        self.assert_eq(pser2.argmin(skipna=False), psser2.argmin(skipna=False))
-        self.assert_eq(pser2.argmax(skipna=False), psser2.argmax(skipna=False))
-
-        # Null Series
-        self.assert_eq(pd.Series([np.nan]).argmin(), ps.Series([np.nan]).argmin())
-        self.assert_eq(pd.Series([np.nan]).argmax(), ps.Series([np.nan]).argmax())
-        self.assert_eq(
-            pd.Series([np.nan]).argmax(skipna=False), ps.Series([np.nan]).argmax(skipna=False)
-        )
-
-        with self.assertRaisesRegex(ValueError, "attempt to get argmin of an empty sequence"):
-            ps.Series([]).argmin()
-        with self.assertRaisesRegex(ValueError, "attempt to get argmax of an empty sequence"):
-            ps.Series([]).argmax()
-        with self.assertRaisesRegex(ValueError, "axis can only be 0 or 'index'"):
-            psser.argmax(axis=1)
-        with self.assertRaisesRegex(ValueError, "axis can only be 0 or 'index'"):
-            psser.argmin(axis=1)
-
-
-class SeriesArgOpsTests(SeriesArgOpsMixin, ComparisonTestBase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.series.test_arg_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/series/test_as_of.py

@@ -1,137 +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 unittest
-
-import numpy as np
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.testing.pandasutils import ComparisonTestBase
-from pyspark.testing.sqlutils import SQLTestUtils
-
-
-class SeriesAsOfMixin:
-    @property
-    def pser(self):
-        return pd.Series([1, 2, 3, 4, 5, 6, 7], name="x")
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    def test_asof(self):
-        pser = pd.Series([1, 2, np.nan, 4], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(psser.asof(20), pser.asof(20))
-        self.assert_eq(psser.asof([5, 20]).sort_index(), pser.asof([5, 20]).sort_index())
-        self.assert_eq(psser.asof(100), pser.asof(100))
-        self.assert_eq(repr(psser.asof(-100)), repr(pser.asof(-100)))
-        self.assert_eq(psser.asof([-100, 100]).sort_index(), pser.asof([-100, 100]).sort_index())
-
-        # where cannot be an Index, Series or a DataFrame
-        self.assertRaises(ValueError, lambda: psser.asof(ps.Index([-100, 100])))
-        self.assertRaises(ValueError, lambda: psser.asof(ps.Series([-100, 100])))
-        self.assertRaises(ValueError, lambda: psser.asof(ps.DataFrame({"A": [1, 2, 3]})))
-        # asof is not supported for a MultiIndex
-        pser.index = pd.MultiIndex.from_tuples([("x", "a"), ("x", "b"), ("y", "c"), ("y", "d")])
-        psser = ps.from_pandas(pser)
-        self.assertRaises(ValueError, lambda: psser.asof(20))
-        # asof requires a sorted index (More precisely, should be a monotonic increasing)
-        psser = ps.Series([1, 2, np.nan, 4], index=[10, 30, 20, 40], name="Koalas")
-        self.assertRaises(ValueError, lambda: psser.asof(20))
-        psser = ps.Series([1, 2, np.nan, 4], index=[40, 30, 20, 10], name="Koalas")
-        self.assertRaises(ValueError, lambda: psser.asof(20))
-
-        pidx = pd.DatetimeIndex(["2013-12-31", "2014-01-02", "2014-01-03"])
-        pser = pd.Series([1, 2, np.nan], index=pidx)
-        psser = ps.from_pandas(pser)
-
-        self.assert_eq(psser.asof("2014-01-01"), pser.asof("2014-01-01"))
-        self.assert_eq(psser.asof("2014-01-02"), pser.asof("2014-01-02"))
-        self.assert_eq(repr(psser.asof("1999-01-02")), repr(pser.asof("1999-01-02")))
-
-        # SPARK-37482: Skip check monotonic increasing for Series.asof with 'compute.eager_check'
-        pser = pd.Series([1, 2, np.nan, 4], index=[10, 30, 20, 40])
-        psser = ps.from_pandas(pser)
-
-        with ps.option_context("compute.eager_check", False):
-            self.assert_eq(psser.asof(20), 1.0)
-
-        pser = pd.Series([1, 2, np.nan, 4], index=[40, 30, 20, 10])
-        psser = ps.from_pandas(pser)
-
-        with ps.option_context("compute.eager_check", False):
-            self.assert_eq(psser.asof(20), 4.0)
-
-        pser = pd.Series([2, 1, np.nan, 4], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof([5, 20]), pser.asof([5, 20]))
-
-        pser = pd.Series([4, np.nan, np.nan, 2], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof([5, 100]), pser.asof([5, 100]))
-
-        pser = pd.Series([np.nan, 4, 1, 2], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof([5, 35]), pser.asof([5, 35]))
-
-        pser = pd.Series([2, 1, np.nan, 4], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof([25, 25]), pser.asof([25, 25]))
-
-        pser = pd.Series([2, 1, np.nan, 4], index=["a", "b", "c", "d"], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof(["a", "d"]), pser.asof(["a", "d"]))
-
-        pser = pd.Series(
-            [2, 1, np.nan, 4],
-            index=[
-                pd.Timestamp(2020, 1, 1),
-                pd.Timestamp(2020, 2, 2),
-                pd.Timestamp(2020, 3, 3),
-                pd.Timestamp(2020, 4, 4),
-            ],
-            name="Koalas",
-        )
-        psser = ps.from_pandas(pser)
-        self.assert_eq(
-            psser.asof([pd.Timestamp(2020, 1, 1)]),
-            pser.asof([pd.Timestamp(2020, 1, 1)]),
-        )
-
-        pser = pd.Series([2, np.nan, 1, 4], index=[10, 20, 30, 40], name="Koalas")
-        psser = ps.from_pandas(pser)
-        self.assert_eq(psser.asof(np.nan), pser.asof(np.nan))
-        self.assert_eq(psser.asof([np.nan, np.nan]), pser.asof([np.nan, np.nan]))
-        self.assert_eq(psser.asof([10, np.nan]), pser.asof([10, np.nan]))
-
-
-class SeriesAsOfTests(SeriesAsOfMixin, ComparisonTestBase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.series.test_as_of 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/series/test_as_type.py

@@ -1,227 +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 unittest
-from distutils.version import LooseVersion
-
-import numpy as np
-import pandas as pd
-
-from pyspark import pandas as ps
-from pyspark.testing.pandasutils import ComparisonTestBase
-from pyspark.testing.sqlutils import SQLTestUtils
-from pyspark.pandas.typedef.typehints import (
-    extension_dtypes,
-    extension_dtypes_available,
-    extension_float_dtypes_available,
-    extension_object_dtypes_available,
-)
-
-
-class SeriesAsTypeMixin:
-    @property
-    def pser(self):
-        return pd.Series([1, 2, 3, 4, 5, 6, 7], name="x")
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    @unittest.skipIf(
-        LooseVersion(pd.__version__) >= LooseVersion("2.0.0"),
-        "TODO(SPARK-43466): Enable SeriesTests.test_astype for pandas 2.0.0.",
-    )
-    def test_astype(self):
-        psers = [pd.Series([10, 20, 15, 30, 45], name="x")]
-
-        if extension_dtypes_available:
-            psers.append(pd.Series([10, 20, 15, 30, 45], name="x", dtype="Int64"))
-        if extension_float_dtypes_available:
-            psers.append(pd.Series([10, 20, 15, 30, 45], name="x", dtype="Float64"))
-
-        for pser in psers:
-            self._test_numeric_astype(pser)
-
-        pser = pd.Series([10, 20, 15, 30, 45, None, np.nan], name="x")
-        psser = ps.Series(pser)
-
-        self.assert_eq(psser.astype(bool), pser.astype(bool))
-        self.assert_eq(psser.astype(str), pser.astype(str))
-
-        pser = pd.Series(["hi", "hi ", " ", " \t", "", None], name="x")
-        psser = ps.Series(pser)
-
-        self.assert_eq(psser.astype(bool), pser.astype(bool))
-        if LooseVersion("1.1.1") <= LooseVersion(pd.__version__) < LooseVersion("1.1.4"):
-            # a pandas bug: https://github.com/databricks/koalas/pull/1818#issuecomment-703961980
-            self.assert_eq(psser.astype(str).tolist(), ["hi", "hi ", " ", " \t", "", "None"])
-        else:
-            self.assert_eq(psser.astype(str), pser.astype(str))
-        self.assert_eq(psser.str.strip().astype(bool), pser.str.strip().astype(bool))
-
-        if extension_object_dtypes_available:
-            from pandas import StringDtype
-
-            self._check_extension(psser.astype("string"), pser.astype("string"))
-            self._check_extension(psser.astype(StringDtype()), pser.astype(StringDtype()))
-
-        pser = pd.Series([True, False, None], name="x")
-        psser = ps.Series(pser)
-
-        self.assert_eq(psser.astype(bool), pser.astype(bool))
-        self.assert_eq(psser.astype(str), pser.astype(str))
-
-        if extension_object_dtypes_available:
-            from pandas import BooleanDtype, StringDtype
-
-            self._check_extension(psser.astype("boolean"), pser.astype("boolean"))
-            self._check_extension(psser.astype(BooleanDtype()), pser.astype(BooleanDtype()))
-
-            if LooseVersion(pd.__version__) >= LooseVersion("1.1"):
-                self._check_extension(psser.astype("string"), pser.astype("string"))
-                self._check_extension(psser.astype(StringDtype()), pser.astype(StringDtype()))
-            else:
-                self._check_extension(
-                    psser.astype("string"),
-                    pd.Series(["True", "False", None], name="x", dtype="string"),
-                )
-                self._check_extension(
-                    psser.astype(StringDtype()),
-                    pd.Series(["True", "False", None], name="x", dtype=StringDtype()),
-                )
-
-        pser = pd.Series(["2020-10-27 00:00:01", None], name="x")
-        psser = ps.Series(pser)
-
-        self.assert_eq(psser.astype(np.datetime64), pser.astype(np.datetime64))
-        self.assert_eq(psser.astype("datetime64[ns]"), pser.astype("datetime64[ns]"))
-        self.assert_eq(psser.astype("M"), pser.astype("M"))
-        self.assert_eq(psser.astype("M").astype(str), pser.astype("M").astype(str))
-        # Comment out the below test cause because pandas returns `NaT` or `nan` randomly
-        # self.assert_eq(
-        #     psser.astype("M").dt.date.astype(str), pser.astype("M").dt.date.astype(str)
-        # )
-
-        if extension_object_dtypes_available:
-            from pandas import StringDtype
-
-            # The behavior of casting datetime to nullable string is changed from pandas 1.3.
-            if LooseVersion(pd.__version__) >= LooseVersion("1.3"):
-                self._check_extension(
-                    psser.astype("M").astype("string"), pser.astype("M").astype("string")
-                )
-                self._check_extension(
-                    psser.astype("M").astype(StringDtype()), pser.astype("M").astype(StringDtype())
-                )
-            else:
-                expected = ps.Series(["2020-10-27 00:00:01", None], name="x", dtype="string")
-                self._check_extension(psser.astype("M").astype("string"), expected)
-                self._check_extension(psser.astype("M").astype(StringDtype()), expected)
-
-        with self.assertRaisesRegex(TypeError, "not understood"):
-            psser.astype("int63")
-
-    def _test_numeric_astype(self, pser):
-        psser = ps.Series(pser)
-
-        self.assert_eq(psser.astype(int), pser.astype(int))
-        self.assert_eq(psser.astype(np.int8), pser.astype(np.int8))
-        self.assert_eq(psser.astype(np.int16), pser.astype(np.int16))
-        self.assert_eq(psser.astype(np.int32), pser.astype(np.int32))
-        self.assert_eq(psser.astype(np.int64), pser.astype(np.int64))
-        self.assert_eq(psser.astype(np.byte), pser.astype(np.byte))
-        self.assert_eq(psser.astype("int"), pser.astype("int"))
-        self.assert_eq(psser.astype("int8"), pser.astype("int8"))
-        self.assert_eq(psser.astype("int16"), pser.astype("int16"))
-        self.assert_eq(psser.astype("int32"), pser.astype("int32"))
-        self.assert_eq(psser.astype("int64"), pser.astype("int64"))
-        self.assert_eq(psser.astype("b"), pser.astype("b"))
-        self.assert_eq(psser.astype("byte"), pser.astype("byte"))
-        self.assert_eq(psser.astype("i"), pser.astype("i"))
-        self.assert_eq(psser.astype("long"), pser.astype("long"))
-        self.assert_eq(psser.astype("short"), pser.astype("short"))
-        self.assert_eq(psser.astype(np.float32), pser.astype(np.float32))
-        self.assert_eq(psser.astype(np.float64), pser.astype(np.float64))
-        self.assert_eq(psser.astype("float"), pser.astype("float"))
-        self.assert_eq(psser.astype("float32"), pser.astype("float32"))
-        self.assert_eq(psser.astype("float64"), pser.astype("float64"))
-        self.assert_eq(psser.astype("double"), pser.astype("double"))
-        self.assert_eq(psser.astype("f"), pser.astype("f"))
-        self.assert_eq(psser.astype(bool), pser.astype(bool))
-        self.assert_eq(psser.astype("bool"), pser.astype("bool"))
-        self.assert_eq(psser.astype("?"), pser.astype("?"))
-        self.assert_eq(psser.astype(np.unicode_), pser.astype(np.unicode_))
-        self.assert_eq(psser.astype("str"), pser.astype("str"))
-        self.assert_eq(psser.astype("U"), pser.astype("U"))
-
-        if extension_dtypes_available:
-            from pandas import Int8Dtype, Int16Dtype, Int32Dtype, Int64Dtype
-
-            self._check_extension(psser.astype("Int8"), pser.astype("Int8"))
-            self._check_extension(psser.astype("Int16"), pser.astype("Int16"))
-            self._check_extension(psser.astype("Int32"), pser.astype("Int32"))
-            self._check_extension(psser.astype("Int64"), pser.astype("Int64"))
-            self._check_extension(psser.astype(Int8Dtype()), pser.astype(Int8Dtype()))
-            self._check_extension(psser.astype(Int16Dtype()), pser.astype(Int16Dtype()))
-            self._check_extension(psser.astype(Int32Dtype()), pser.astype(Int32Dtype()))
-            self._check_extension(psser.astype(Int64Dtype()), pser.astype(Int64Dtype()))
-
-        if extension_object_dtypes_available:
-            from pandas import StringDtype
-
-            if LooseVersion(pd.__version__) >= LooseVersion("1.1"):
-                self._check_extension(psser.astype("string"), pser.astype("string"))
-                self._check_extension(psser.astype(StringDtype()), pser.astype(StringDtype()))
-            else:
-                self._check_extension(
-                    psser.astype("string"),
-                    pd.Series(["10", "20", "15", "30", "45"], name="x", dtype="string"),
-                )
-                self._check_extension(
-                    psser.astype(StringDtype()),
-                    pd.Series(["10", "20", "15", "30", "45"], name="x", dtype=StringDtype()),
-                )
-
-        if extension_float_dtypes_available:
-            from pandas import Float32Dtype, Float64Dtype
-
-            self._check_extension(psser.astype("Float32"), pser.astype("Float32"))
-            self._check_extension(psser.astype("Float64"), pser.astype("Float64"))
-            self._check_extension(psser.astype(Float32Dtype()), pser.astype(Float32Dtype()))
-            self._check_extension(psser.astype(Float64Dtype()), pser.astype(Float64Dtype()))
-
-    def _check_extension(self, psser, pser):
-        if LooseVersion("1.1") <= LooseVersion(pd.__version__) < LooseVersion("1.2.2"):
-            self.assert_eq(psser, pser, check_exact=False)
-            self.assertTrue(isinstance(psser.dtype, extension_dtypes))
-        else:
-            self.assert_eq(psser, pser)
-
-
-class SeriesAsTypeTests(SeriesAsTypeMixin, ComparisonTestBase, SQLTestUtils):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.series.test_as_type 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)