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

snowflake/snowpark_connect/includes/python/pyspark/pandas/tests/connect/test_parity_utils.py

@@ -1,37 +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 pyspark.pandas.tests.test_utils import UtilsTestsMixin
-from pyspark.testing.connectutils import ReusedConnectTestCase
-from pyspark.testing.pandasutils import PandasOnSparkTestUtils
-
-
-class UtilsParityTests(UtilsTestsMixin, PandasOnSparkTestUtils, ReusedConnectTestCase):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.connect.test_parity_utils import *  # noqa: F401
-
-    try:
-        import xmlrunner  # type: ignore[import]
-
-        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/connect/test_parity_window.py

@@ -1,39 +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 pyspark.pandas.tests.test_window import ExpandingRollingTestsMixin
-from pyspark.testing.connectutils import ReusedConnectTestCase
-from pyspark.testing.pandasutils import PandasOnSparkTestUtils, TestUtils
-
-
-class ExpandingRollingParityTests(
-    ExpandingRollingTestsMixin, PandasOnSparkTestUtils, TestUtils, ReusedConnectTestCase
-):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.connect.test_parity_window import *  # noqa: F401
-
-    try:
-        import xmlrunner  # type: ignore[import]
-
-        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/__init__.py

@@ -1,16 +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.
-#

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

@@ -1,107 +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 pandas.api.types import CategoricalDtype
-from pandas.api.extensions import ExtensionDtype
-
-from pyspark.pandas.data_type_ops.base import DataTypeOps
-from pyspark.pandas.data_type_ops.binary_ops import BinaryOps
-from pyspark.pandas.data_type_ops.boolean_ops import BooleanOps, BooleanExtensionOps
-from pyspark.pandas.data_type_ops.categorical_ops import CategoricalOps
-from pyspark.pandas.data_type_ops.complex_ops import ArrayOps, MapOps, StructOps
-from pyspark.pandas.data_type_ops.date_ops import DateOps
-from pyspark.pandas.data_type_ops.datetime_ops import DatetimeOps, DatetimeNTZOps
-from pyspark.pandas.data_type_ops.null_ops import NullOps
-from pyspark.pandas.data_type_ops.num_ops import IntegralOps, FractionalOps, DecimalOps
-from pyspark.pandas.data_type_ops.string_ops import StringOps
-from pyspark.pandas.data_type_ops.timedelta_ops import TimedeltaOps
-from pyspark.pandas.data_type_ops.udt_ops import UDTOps
-from pyspark.sql.types import (
-    ArrayType,
-    BinaryType,
-    BooleanType,
-    DataType,
-    DateType,
-    DayTimeIntervalType,
-    DecimalType,
-    FractionalType,
-    IntegralType,
-    MapType,
-    NullType,
-    StringType,
-    StructType,
-    TimestampType,
-    TimestampNTZType,
-    UserDefinedType,
-)
-
-
-class BaseTestsMixin:
-    def test_data_type_ops(self):
-        _mock_spark_type = DataType()
-        _mock_dtype = ExtensionDtype()
-        _mappings = (
-            (CategoricalDtype(), _mock_spark_type, CategoricalOps),
-            (_mock_dtype, DecimalType(), DecimalOps),
-            (_mock_dtype, FractionalType(), FractionalOps),
-            (_mock_dtype, IntegralType(), IntegralOps),
-            (_mock_dtype, StringType(), StringOps),
-            (_mock_dtype, BooleanType(), BooleanOps),
-            (_mock_dtype, TimestampType(), DatetimeOps),
-            (_mock_dtype, TimestampNTZType(), DatetimeNTZOps),
-            (_mock_dtype, DateType(), DateOps),
-            (_mock_dtype, DayTimeIntervalType(), TimedeltaOps),
-            (_mock_dtype, BinaryType(), BinaryOps),
-            (_mock_dtype, ArrayType(StringType()), ArrayOps),
-            (_mock_dtype, MapType(StringType(), IntegralType()), MapOps),
-            (_mock_dtype, StructType(), StructOps),
-            (_mock_dtype, NullType(), NullOps),
-            (_mock_dtype, UserDefinedType(), UDTOps),
-        )
-        for _dtype, _spark_type, _ops in _mappings:
-            self.assertIsInstance(DataTypeOps(_dtype, _spark_type), _ops)
-
-        _unknow_spark_type = _mock_spark_type
-        self.assertRaises(TypeError, DataTypeOps, BooleanType(), _unknow_spark_type)
-
-    def test_bool_ext_ops(self):
-        from pyspark.pandas.typedef.typehints import extension_object_dtypes_available
-
-        if extension_object_dtypes_available:
-            from pandas import BooleanDtype
-
-            self.assertIsInstance(DataTypeOps(BooleanDtype(), BooleanType()), BooleanExtensionOps)
-        else:
-            self.assertIsInstance(DataTypeOps(ExtensionDtype(), BooleanType()), BooleanOps)
-
-
-class BaseTests(BaseTestsMixin, unittest.TestCase):
-    pass
-
-
-if __name__ == "__main__":
-    from pyspark.pandas.tests.data_type_ops.test_base 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_binary_ops.py

@@ -1,224 +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
-
-from pyspark import pandas as ps
-from pyspark.pandas.tests.data_type_ops.testing_utils import OpsTestBase
-
-
-class BinaryOpsTestsMixin:
-    @property
-    def pser(self):
-        return pd.Series([b"1", b"2", b"3"])
-
-    @property
-    def psser(self):
-        return ps.from_pandas(self.pser)
-
-    @property
-    def byte_pdf(self):
-        psers = {
-            "this": self.pser,
-            "that": pd.Series([b"2", b"3", b"4"]),
-        }
-        return pd.concat(psers, axis=1)
-
-    @property
-    def byte_psdf(self):
-        return ps.from_pandas(self.byte_pdf)
-
-    def test_add(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        pser, psser = byte_pdf["this"], byte_psdf["this"]
-        other_pser, other_psser = byte_pdf["that"], byte_psdf["that"]
-
-        self.assert_eq(psser + b"1", pser + b"1")
-        self.assert_eq(psser + psser, pser + pser)
-        self.assert_eq(psser + psser.astype("bytes"), pser + pser.astype("bytes"))
-        self.assertRaises(TypeError, lambda: psser + "x")
-        self.assertRaises(TypeError, lambda: psser + 1)
-
-        self.assert_eq(pser + pser, psser + psser)
-        self.assert_eq(pser + other_pser, psser + other_psser)
-
-        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.assert_eq(b"1" + self.psser, b"1" + self.pser)
-        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):
-        data = [b"1", b"2", b"3"]
-        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(psser.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=[b"2", b"3", b"1"])
-        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):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] == byte_pdf["that"], byte_psdf["this"] == byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] == byte_pdf["this"], byte_psdf["this"] == byte_psdf["this"])
-
-    def test_ne(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] != byte_pdf["that"], byte_psdf["this"] != byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] != byte_pdf["this"], byte_psdf["this"] != byte_psdf["this"])
-
-    def test_lt(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] < byte_pdf["that"], byte_psdf["this"] < byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] < byte_pdf["this"], byte_psdf["this"] < byte_psdf["this"])
-
-    def test_le(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] <= byte_pdf["that"], byte_psdf["this"] <= byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] <= byte_pdf["this"], byte_psdf["this"] <= byte_psdf["this"])
-
-    def test_gt(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] > byte_pdf["that"], byte_psdf["this"] > byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] > byte_pdf["this"], byte_psdf["this"] > byte_psdf["this"])
-
-    def test_ge(self):
-        byte_pdf, byte_psdf = self.byte_pdf, self.byte_psdf
-        self.assert_eq(byte_pdf["this"] >= byte_pdf["that"], byte_psdf["this"] >= byte_psdf["that"])
-        self.assert_eq(byte_pdf["this"] >= byte_pdf["this"], byte_psdf["this"] >= byte_psdf["this"])
-
-
-class BinaryOpsTests(BinaryOpsTestsMixin, OpsTestBase):
-    pass
-
-
-if __name__ == "__main__":
-    import unittest
-    from pyspark.pandas.tests.data_type_ops.test_binary_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)