Added more logical operations nodes to handle scalar comparison.

2025-03-07 15:54:36 -08:00
parent f918096cb6
commit c20da5b545
52 changed files with 2033 additions and 4 deletions
@@ -0,0 +1,76 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_boolean_index import PandasBooleanIndex
+
+class TestPandasBooleanIndex(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasBooleanIndex()
+        self.valid_test_cases = [
+            # Basic boolean indexing
+            (
+                pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}, index=["x", "y", "z"]),
+                pd.Series([True, False, True], index=["x", "y", "z"]),
+                pd.DataFrame({"a": [1, 3], "b": [4, 6]}, index=["x", "z"])
+            ),
+            # All True case
+            (
+                pd.DataFrame({"a": [10, 20, 30]}),
+                pd.Series([True, True, True]),
+                pd.DataFrame({"a": [10, 20, 30]})
+            ),
+            # All False case
+            (
+                pd.DataFrame({"a": [100, 200, 300]}),
+                pd.Series([False, False, False]),
+                pd.DataFrame({"a": []}).astype("int64")
+            ),
+            # Mixed True/False with different index labels
+            (
+                pd.DataFrame({"a": [1.1, 2.2, 3.3]}, index=["row1", "row2", "row3"]),
+                pd.Series([False, True, False], index=["row1", "row2", "row3"]),
+                pd.DataFrame({"a": [2.2]}, index=["row2"])
+            ),
+        ]
+
+        self.invalid_test_cases = [
+            # Series with incorrect index
+            (
+                pd.DataFrame({"a": [1, 2, 3]}, index=["x", "y", "z"]),
+                pd.Series([True, False], index=["x", "y"]),  # Mismatched length
+            ),
+            # Non-boolean Series
+            (
+                pd.DataFrame({"a": [1, 2, 3]}, index=["x", "y", "z"]),
+                pd.Series([1, 0, 1], index=["x", "y", "z"]),  # Non-boolean values
+            ),
+            # Non-Series boolean index
+            (
+                pd.DataFrame({"a": [1, 2, 3]}, index=["x", "y", "z"]),
+                [True, False, True],  # List instead of Series
+            ),
+        ]
+
+    def test_boolean_indexing(self):
+        """Test filtering DataFrame rows based on boolean Series."""
+        for dataframe, boolean_series, expected_df in self.valid_test_cases:
+            with self.subTest(dataframe=dataframe, boolean_series=boolean_series):
+                retval = self.node.f(dataframe, boolean_series)[0]
+                self.assertTrue(isinstance(retval, pd.DataFrame), "Expected DataFrame output.")
+                pd.testing.assert_frame_equal(retval, expected_df)
+
+    def test_invalid_inputs(self):
+        """Test that invalid inputs raise errors."""
+        for dataframe, boolean_series in self.invalid_test_cases:
+            with self.subTest(dataframe=dataframe, boolean_series=boolean_series):
+                with self.assertRaises(Exception):
+                    self.node.f(dataframe, boolean_series)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,78 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_create_series_from_list_index_list import PandasCreateSeriesFromListIndexList
+
+class TestPandasCreateSeriesFromListIndexList(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasCreateSeriesFromListIndexList()
+        self.valid_test_cases = [
+            # Empty list
+            ([], [], pd.Series([])),
+
+            # List with single values
+            ([12345], ["a"], pd.Series([12345], index=["a"])),
+            ([12345.6], [1], pd.Series([12345.6], index=[1])),
+            (["apple"], ["fruit"], pd.Series(["apple"], index=["fruit"])),
+            ([True], ["flag"], pd.Series([True], index=["flag"])),
+            ([None], ["null"], pd.Series([None], index=["null"])),
+            
+            # List with multiple values
+            ([123, 456], ["a", "b"], pd.Series([123, 456], index=["a", "b"])),
+            ([1.5, 3.2, -7.8], ["x", "y", "z"], pd.Series([1.5, 3.2, -7.8], index=["x", "y", "z"])),
+            (["Alice", 30, "NYC"], ["name", "age", "city"], pd.Series(["Alice", 30, "NYC"], index=["name", "age", "city"])),
+            ([False, 99, 3.14159], ["flag", "score", "pi"], pd.Series([False, 99, 3.14159], index=["flag", "score", "pi"]))
+        ]
+
+        self.invalid_test_cases_value_error = [
+            # Non-list inputs
+            (None, []),
+            ({}, []),
+            ((), []),
+            ("string", []),
+            (1234, []),
+            (56.78, []),
+            ({1, 2, 3}, []),  # Set
+            ({"a": 1}, []),  # Dict
+            ([1, 2], ["a"])  # Mismatched data and index length
+        ]
+
+        self.invalid_test_cases_type_error = [
+            ([1, 2, 3], "invalid"),  # Invalid index type
+        ]
+
+    def test_create_series(self):
+        """Test Series creation from lists with index."""
+        for data, index, expected_series in self.valid_test_cases:
+            with self.subTest(data=data, index=index):
+                retval = self.node.f(data, index)[0]
+
+                # Test if output is a Pandas Series
+                self.assertTrue(isinstance(retval, pd.Series), f"Expected Series, got {type(retval)}")
+
+                # Test if Series matches expected output
+                pd.testing.assert_series_equal(retval, expected_series)
+
+    def test_invalid_inputs_type_error(self):
+        """Test that invalid inputs raise TypeError."""
+        for data, index in self.invalid_test_cases_type_error:
+            with self.subTest(data=data, index=index):
+                with self.assertRaises(TypeError):
+                    self.node.f(data, index)
+
+    def test_invalid_inputs_value_error(self):
+        """Test that invalid inputs raise ValueError."""
+        for data, index in self.invalid_test_cases_value_error:
+            with self.subTest(data=data, index=index):
+                with self.assertRaises(ValueError):
+                    self.node.f(data, index)
+
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,65 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_create_series_from_list import PandasCreateSeriesFromList
+
+class TestPandasCreateSeriesFromList(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasCreateSeriesFromList()
+        self.valid_test_cases = [
+            # Empty list
+            ([], pd.Series([])),
+
+            # List with single values
+            ([12345], pd.Series([12345])),
+            ([12345.6], pd.Series([12345.6])),
+            (["apple"], pd.Series(["apple"])),
+            ([True], pd.Series([True])),
+            ([None], pd.Series([None])),
+            
+            # List with multiple values
+            ([123, 456], pd.Series([123, 456])),
+            ([1.5, 3.2, -7.8], pd.Series([1.5, 3.2, -7.8])),
+            (["Alice", 30, "NYC"], pd.Series(["Alice", 30, "NYC"])),
+            ([False, 99, 3.14159], pd.Series([False, 99, 3.14159]))
+        ]
+
+        self.invalid_test_cases = [
+            # Non-list inputs
+            None,
+            {},
+            (),
+            "string",
+            1234,
+            56.78,
+            {1, 2, 3},  # Set
+            {"a": 1},  # Dict
+        ]
+
+    def test_create_series(self):
+        """Test Series creation from lists."""
+        for data, expected_series in self.valid_test_cases:
+            with self.subTest(data=data):
+                retval = self.node.f(data)[0]
+
+                # Test if output is a Pandas Series
+                self.assertTrue(isinstance(retval, pd.Series), f"Expected Series, got {type(retval)}")
+
+                # Test if Series matches expected output
+                pd.testing.assert_series_equal(retval, expected_series)
+
+    def test_invalid_inputs(self):
+        """Test that invalid inputs raise ValueError."""
+        for data in self.invalid_test_cases:
+            with self.subTest(data=data):
+                with self.assertRaises(ValueError):
+                    self.node.f(data)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_eq_scalar_float import PandasEqScalarFloat
+
+class TestPandasEqScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasEqScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2.5,
+                pd.DataFrame({"a": [True, False]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                4.9,
+                pd.DataFrame({"a": [False, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                26.0,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7.0,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7.0]}, index=["row1"]),
+                7.0,
+                pd.DataFrame({2: [True]}, index=["row1"])
+            ),
+        ]
+
+    def test_eq_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_eq_scalar_int import PandasEqScalarInt
+
+class TestPandasEqScalarInt(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasEqScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2, 3.5]}, index=["row1", "row2"]),
+                2,
+                pd.DataFrame({"a": [True, False]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4]}, index=[0, 1]),
+                4,
+                pd.DataFrame({"a": [False, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 15]}, index=[0, 1]),
+                15,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7]}, index=["row1"]),
+                7,
+                pd.DataFrame({2: [True]}, index=["row1"])
+            ),
+        ]
+
+    def test_eq_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_ge_scalar_float import PandasGeScalarFloat
+
+class TestPandasGeScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasGeScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2.1,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                3.1,
+                pd.DataFrame({"a": [True, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                15.1,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a < b)
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7.1,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7.5]}, index=["row1"]),
+                7.5,
+                pd.DataFrame({2: [True]}, index=["row1"])
+            ),
+        ]
+
+    def test_ge_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_ge_scalar_int import PandasGeScalarInt
+
+class TestPandasGtScalarInt(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasGeScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                4,
+                pd.DataFrame({"a": [False, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                15,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a < b)
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7]}, index=["row1"]),
+                7,
+                pd.DataFrame({2: [True]}, index=["row1"])
+            ),
+        ]
+
+    def test_ge_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_gt_scalar_float import PandasGtScalarFloat
+
+class TestPandasGtScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasGtScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2.1,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                4.1,
+                pd.DataFrame({"a": [False, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                15.1,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a < b)
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7.1,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7.5]}, index=["row1"]),
+                7.5,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_gt_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_gt_scalar_int import PandasGtScalarInt
+
+class TestPandasGtScalarInt(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasGtScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                4,
+                pd.DataFrame({"a": [False, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                15,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a < b)
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                7,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7]}, index=["row1"]),
+                7,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_gt_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_le_scalar_float import PandasLeScalarFloat
+
+class TestPandasLeScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasLeScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [1.5, 2.5]}, index=["row1", "row2"]),
+                3.1,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with integer (still True)
+            (
+                pd.DataFrame({"a": [3, 4]}, index=[0, 1]),
+                5.1,
+                pd.DataFrame({"a": [True, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels (True)
+            (
+                pd.DataFrame({1: [10.0, 25.1]}, index=[0, 1]),
+                25.1,
+                pd.DataFrame({1: [True, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a > b)
+            (
+                pd.DataFrame({"a": [7.0]}, index=["row1"]),
+                6.5,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [9.5]}, index=["row1"]),
+                8.1,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_le_operation(self):
+        """Test less-than-or-equal operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_le_scalar_int import PandasLeScalarInt
+
+class TestPandasLeScalarInt(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasLeScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [1.5, 2.5]}, index=["row1", "row2"]),
+                3,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with integer (still True)
+            (
+                pd.DataFrame({"a": [3, 4]}, index=[0, 1]),
+                5,
+                pd.DataFrame({"a": [True, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels (True)
+            (
+                pd.DataFrame({1: [10.0, 25]}, index=[0, 1]),
+                25,
+                pd.DataFrame({1: [True, True]}, index=[0, 1])
+            ),
+            # Test with a False case (a > b)
+            (
+                pd.DataFrame({"a": [7.0]}, index=["row1"]),
+                6,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [9.5]}, index=["row1"]),
+                8,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_le_operation(self):
+        """Test less-than-or-equal operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_lt_scalar_float import PandasLtScalarFloat
+
+class TestPandasLeScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasLtScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [1.5, 2.5]}, index=["row1", "row2"]),
+                3.1,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with integer (still True)
+            (
+                pd.DataFrame({"a": [3, 4]}, index=[0, 1]),
+                5.1,
+                pd.DataFrame({"a": [True, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [10.0, 25.1]}, index=[0, 1]),
+                25.1,
+                pd.DataFrame({1: [True, False]}, index=[0, 1])
+            ),
+            # Test with a False case (a > b)
+            (
+                pd.DataFrame({"a": [7.0]}, index=["row1"]),
+                6.5,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [9.5]}, index=["row1"]),
+                8.1,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_le_operation(self):
+        """Test less-than-or-equal operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_lt_scalar_int import PandasLtScalarInt
+
+class TestPandasLtScalarInt(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasLtScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [1.5, 2.5]}, index=["row1", "row2"]),
+                3,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with integer (still True)
+            (
+                pd.DataFrame({"a": [3, 4]}, index=[0, 1]),
+                5,
+                pd.DataFrame({"a": [True, True]}, index=[0, 1])
+            ),
+            # Test with integer column labels (True)
+            (
+                pd.DataFrame({1: [10.0, 25]}, index=[0, 1]),
+                25,
+                pd.DataFrame({1: [True, False]}, index=[0, 1])
+            ),
+            # Test with a False case (a > b)
+            (
+                pd.DataFrame({"a": [7.0]}, index=["row1"]),
+                6,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [9.5]}, index=["row1"]),
+                8,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_le_operation(self):
+        """Test less-than-or-equal operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_ne_scalar_float import PandasNeScalarFloat
+
+class TestPandasNeScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasNeScalarFloat()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2.1,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4.9]}, index=[0, 1]),
+                4.9,
+                pd.DataFrame({"a": [True, False]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14.0, 26.0]}, index=[0, 1]),
+                14.0,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case
+            (
+                pd.DataFrame({"a": [6.0]}, index=["row1"]),
+                6.0,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [7.5]}, index=["row1"]),
+                7.5,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_ne_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,58 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_ne_scalar_int import PandasNeScalarInt
+
+class TestPandasNeScalarFloat(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasNeScalarInt()
+        self.test_cases = [
+            # Test where all values are True
+            (
+                pd.DataFrame({"a": [2.5, 3.5]}, index=["row1", "row2"]),
+                2,
+                pd.DataFrame({"a": [True, True]}, index=["row1", "row2"])
+            ),
+            # Test with mixed result
+            (
+                pd.DataFrame({"a": [3.6, 4]}, index=[0, 1]),
+                4,
+                pd.DataFrame({"a": [True, False]}, index=[0, 1])
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [14, 26.0]}, index=[0, 1]),
+                14,
+                pd.DataFrame({1: [False, True]}, index=[0, 1])
+            ),
+            # Test with a False case
+            (
+                pd.DataFrame({"a": [6]}, index=["row1"]),
+                6,
+                pd.DataFrame({"a": [False]}, index=["row1"])
+            ),
+            # Another False case with an integer column label
+            (
+                pd.DataFrame({2: [8]}, index=["row1"]),
+                8,
+                pd.DataFrame({2: [False]}, index=["row1"])
+            ),
+        ]
+
+    def test_ne_operation(self):
+        """Test greater-than operation between two pandas DataFrames."""
+        for df_a, df_b, expected in self.test_cases:
+            with self.subTest(df_a=df_a, df_b=df_b):
+                retval = self.node.f(df_a, df_b)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single DataFrame.")
+                pd.testing.assert_frame_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()
@@ -0,0 +1,52 @@
+import os
+import sys
+import unittest
+import pandas as pd
+
+PROJECT_ROOT = os.path.realpath(os.path.join(os.path.dirname(__file__), "..", ".."))
+MODULE_ROOT = os.path.join(PROJECT_ROOT, "modules")
+sys.path.append(MODULE_ROOT)
+from pandas_wrapper.pandas_select_column_as_series import PandasSelectColumnAsSeries
+
+class TestPandasSelectColumnAsSeries(unittest.TestCase):
+    def setUp(self):
+        """Set up test data."""
+        self.node = PandasSelectColumnAsSeries()
+        self.test_cases = [
+            # Test with a simple DataFrame
+            (
+                pd.DataFrame({"a": [1, 2, 3], "b": [4, 5, 6]}),
+                "a",
+                pd.Series([1, 2, 3], name="a")
+            ),
+            # Test with a DataFrame with different data types
+            (
+                pd.DataFrame({"x": ["foo", "bar"], "y": [10.5, 20.5]}),
+                "y",
+                pd.Series([10.5, 20.5], name="y")
+            ),
+            # Test with integer column labels
+            (
+                pd.DataFrame({1: [100, 200], 2: [300, 400]}),
+                1,
+                pd.Series([100, 200], name=1)
+            ),
+            # Test with single-row DataFrame
+            (
+                pd.DataFrame({"col": [42]}),
+                "col",
+                pd.Series([42], name="col")
+            ),
+        ]
+
+    def test_select_column_as_series(self):
+        """Test selecting a column as a pandas Series."""
+        for df, column_name, expected in self.test_cases:
+            with self.subTest(df=df, column_name=column_name):
+                retval = self.node.f(df, column_name)
+                self.assertIsInstance(retval, tuple, "Return value should be a tuple.")
+                self.assertEqual(len(retval), 1, "Return tuple should have a single Series.")
+                pd.testing.assert_series_equal(retval[0], expected)
+
+if __name__ == "__main__":
+    unittest.main()