nodes/HowToSD-ComfyUI-Data-Analysis
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added more logical operations nodes to handle scalar comparison.

Browse Source
This commit is contained in:
HowToSD
2025-03-07 15:54:36 -08:00
parent f918096cb6
commit c20da5b545
52 changed files with 2033 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files
__init__.py
+48
View File
@@ -41,6 +41,7 @@ from .modules.pandas_wrapper.pandas_at_set_float import PandasAtSetFloat
from .modules.pandas_wrapper.pandas_at_set_int import PandasAtSetInt
from .modules.pandas_wrapper.pandas_at_set_string import PandasAtSetString
from .modules.pandas_wrapper.pandas_at_string import PandasAtString
from .modules.pandas_wrapper.pandas_boolean_index import PandasBooleanIndex
from .modules.pandas_wrapper.pandas_columns import PandasColumns
from .modules.pandas_wrapper.pandas_corr import PandasCorr
from .modules.pandas_wrapper.pandas_cos import PandasCos
@@ -53,6 +54,8 @@ from .modules.pandas_wrapper.pandas_create_from_multiple_dict import PandasCreat
from .modules.pandas_wrapper.pandas_create_from_numpy import PandasCreateFromNumpy
from .modules.pandas_wrapper.pandas_create_from_tensor import PandasCreateFromTensor
from .modules.pandas_wrapper.pandas_create_series_from_dict import PandasCreateSeriesFromDict
from .modules.pandas_wrapper.pandas_create_series_from_list import PandasCreateSeriesFromList
from .modules.pandas_wrapper.pandas_create_series_from_list_index_list import PandasCreateSeriesFromListIndexList
from .modules.pandas_wrapper.pandas_create_with_index import PandasCreateWithIndex
from .modules.pandas_wrapper.pandas_crosstab import PandasCrosstab
from .modules.pandas_wrapper.pandas_cummax import PandasCummax
@@ -66,13 +69,19 @@ from .modules.pandas_wrapper.pandas_div_series import PandasDivSeries
from .modules.pandas_wrapper.pandas_drop_duplicates import PandasDropDuplicates
from .modules.pandas_wrapper.pandas_dropna import PandasDropNA
from .modules.pandas_wrapper.pandas_eq import PandasEq
from .modules.pandas_wrapper.pandas_eq_scalar_float import PandasEqScalarFloat
from .modules.pandas_wrapper.pandas_eq_scalar_int import PandasEqScalarInt
from .modules.pandas_wrapper.pandas_exp import PandasExp
from .modules.pandas_wrapper.pandas_feature_split_to_numpy import PandasFeatureSplitToNumpy
from .modules.pandas_wrapper.pandas_fillna_scalar_float import PandasFillNAScalarFloat
from .modules.pandas_wrapper.pandas_fillna_scalar_int import PandasFillNAScalarInt
from .modules.pandas_wrapper.pandas_ge import PandasGe
from .modules.pandas_wrapper.pandas_ge_scalar_float import PandasGeScalarFloat
from .modules.pandas_wrapper.pandas_ge_scalar_int import PandasGeScalarInt
from .modules.pandas_wrapper.pandas_group_by import PandasGroupBy
from .modules.pandas_wrapper.pandas_gt import PandasGt
from .modules.pandas_wrapper.pandas_gt_scalar_float import PandasGtScalarFloat
from .modules.pandas_wrapper.pandas_gt_scalar_int import PandasGtScalarInt
from .modules.pandas_wrapper.pandas_head import PandasHead
from .modules.pandas_wrapper.pandas_horizontal_concat import PandasHorizontalConcat
from .modules.pandas_wrapper.pandas_horizontal_split import PandasHorizontalSplit
@@ -93,6 +102,8 @@ from .modules.pandas_wrapper.pandas_isna import PandasIsNA
from .modules.pandas_wrapper.pandas_join import PandasJoin
from .modules.pandas_wrapper.pandas_kurtosis import PandasKurtosis
from .modules.pandas_wrapper.pandas_le import PandasLe
from .modules.pandas_wrapper.pandas_le_scalar_float import PandasLeScalarFloat
from .modules.pandas_wrapper.pandas_le_scalar_int import PandasLeScalarInt
from .modules.pandas_wrapper.pandas_load_csv import PandasLoadCSV
from .modules.pandas_wrapper.pandas_load_csv_with_encoding import PandasLoadCSVWithEncoding
from .modules.pandas_wrapper.pandas_load_csv_with_index import PandasLoadCSVWithIndex
@@ -104,6 +115,8 @@ from .modules.pandas_wrapper.pandas_loc_row_multiindex_dataframe import PandasLo
from .modules.pandas_wrapper.pandas_loc_row_series import PandasLocRowSeries
from .modules.pandas_wrapper.pandas_log import PandasLog
from .modules.pandas_wrapper.pandas_lt import PandasLt
from .modules.pandas_wrapper.pandas_lt_scalar_float import PandasLtScalarFloat
from .modules.pandas_wrapper.pandas_lt_scalar_int import PandasLtScalarInt
from .modules.pandas_wrapper.pandas_max import PandasMax
from .modules.pandas_wrapper.pandas_mean import PandasMean
from .modules.pandas_wrapper.pandas_median import PandasMedian
@@ -115,6 +128,8 @@ from .modules.pandas_wrapper.pandas_mul_scalar_float import PandasMulScalarFloat
from .modules.pandas_wrapper.pandas_mul_scalar_int import PandasMulScalarInt
from .modules.pandas_wrapper.pandas_mul_series import PandasMulSeries
from .modules.pandas_wrapper.pandas_ne import PandasNe
from .modules.pandas_wrapper.pandas_ne_scalar_float import PandasNeScalarFloat
from .modules.pandas_wrapper.pandas_ne_scalar_int import PandasNeScalarInt
from .modules.pandas_wrapper.pandas_pivot import PandasPivot
from .modules.pandas_wrapper.pandas_pow import PandasPow
from .modules.pandas_wrapper.pandas_pow_scalar_float import PandasPowScalarFloat
@@ -125,6 +140,7 @@ from .modules.pandas_wrapper.pandas_rename_advanced import PandasRenameAdvanced
from .modules.pandas_wrapper.pandas_replace import PandasReplace
from .modules.pandas_wrapper.pandas_save_csv import PandasSaveCSV
from .modules.pandas_wrapper.pandas_save_json import PandasSaveJSON
from .modules.pandas_wrapper.pandas_select_column_as_series import PandasSelectColumnAsSeries
from .modules.pandas_wrapper.pandas_select_columns import PandasSelectColumns
from .modules.pandas_wrapper.pandas_select_rows import PandasSelectRows
from .modules.pandas_wrapper.pandas_series_to_dataframe import PandasSeriesToDataFrame
@@ -300,6 +316,7 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasAtSetInt": PandasAtSetInt,
"PandasAtSetString": PandasAtSetString,
"PandasAtString": PandasAtString,
"PandasBooleanIndex": PandasBooleanIndex,
"PandasColumns": PandasColumns,
"PandasCorr": PandasCorr,
"PandasCos": PandasCos,
@@ -312,6 +329,8 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasCreateFromNumpy": PandasCreateFromNumpy,
"PandasCreateFromTensor": PandasCreateFromTensor,
"PandasCreateSeriesFromDict": PandasCreateSeriesFromDict,
"PandasCreateSeriesFromList": PandasCreateSeriesFromList,
"PandasCreateSeriesFromListIndexList": PandasCreateSeriesFromListIndexList,
"PandasCreateWithIndex": PandasCreateWithIndex,
"PandasCrosstab": PandasCrosstab,
"PandasCummax": PandasCummax,
@@ -325,13 +344,19 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasDropDuplicates": PandasDropDuplicates,
"PandasDropNA": PandasDropNA,
"PandasEq": PandasEq,
"PandasEqScalarFloat": PandasEqScalarFloat,
"PandasEqScalarInt": PandasEqScalarInt,
"PandasExp": PandasExp,
"PandasFeatureSplitToNumpy": PandasFeatureSplitToNumpy,
"PandasFillNAScalarFloat": PandasFillNAScalarFloat,
"PandasFillNAScalarInt": PandasFillNAScalarInt,
"PandasGe": PandasGe,
"PandasGeScalarFloat": PandasGeScalarFloat,
"PandasGeScalarInt": PandasGeScalarInt,
"PandasGroupBy": PandasGroupBy,
"PandasGt": PandasGt,
"PandasGtScalarFloat": PandasGtScalarFloat,
"PandasGtScalarInt": PandasGtScalarInt,
"PandasHead": PandasHead,
"PandasHorizontalConcat": PandasHorizontalConcat,
"PandasHorizontalSplit": PandasHorizontalSplit,
@@ -352,6 +377,8 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasJoin": PandasJoin,
"PandasKurtosis": PandasKurtosis,
"PandasLe": PandasLe,
"PandasLeScalarFloat": PandasLeScalarFloat,
"PandasLeScalarInt": PandasLeScalarInt,
"PandasLoadCSV": PandasLoadCSV,
"PandasLoadCSVWithEncoding": PandasLoadCSVWithEncoding,
"PandasLoadCSVWithIndex": PandasLoadCSVWithIndex,
@@ -363,6 +390,8 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasLocRowSeries": PandasLocRowSeries,
"PandasLog": PandasLog,
"PandasLt": PandasLt,
"PandasLtScalarFloat": PandasLtScalarFloat,
"PandasLtScalarInt": PandasLtScalarInt,
"PandasMax": PandasMax,
"PandasMean": PandasMean,
"PandasMedian": PandasMedian,
@@ -374,6 +403,8 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasMulScalarInt": PandasMulScalarInt,
"PandasMulSeries": PandasMulSeries,
"PandasNe": PandasNe,
"PandasNeScalarFloat": PandasNeScalarFloat,
"PandasNeScalarInt": PandasNeScalarInt,
"PandasPivot": PandasPivot,
"PandasPow": PandasPow,
"PandasPowScalarFloat": PandasPowScalarFloat,
@@ -384,6 +415,7 @@ NODE_CLASS_MAPPINGS: Dict[str, Type[T]] = {
"PandasReplace": PandasReplace,
"PandasSaveCSV": PandasSaveCSV,
"PandasSaveJSON": PandasSaveJSON,
"PandasSelectColumnAsSeries": PandasSelectColumnAsSeries,
"PandasSelectColumns": PandasSelectColumns,
"PandasSelectRows": PandasSelectRows,
"PandasSeriesToDataFrame": PandasSeriesToDataFrame,
@@ -570,6 +602,7 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasAtSetInt": "Pandas At Set Int",
"PandasAtSetString": "Pandas At Set String",
"PandasAtString": "Pandas At String",
"PandasBooleanIndex": "Pandas Boolean Index",
"PandasColumns": "Pandas Columns",
"PandasCorr": "Pandas Corr",
"PandasCos": "Pandas Cos",
@@ -582,6 +615,8 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasCreateFromNumpy": "Pandas Create From Numpy",
"PandasCreateFromTensor": "Pandas Create From Tensor",
"PandasCreateSeriesFromDict": "Pandas Create Series From Dict",
"PandasCreateSeriesFromList": "Pandas Create Series From List",
"PandasCreateSeriesFromListIndexList": "Pandas Create Series From List Index List",
"PandasCreateWithIndex": "Pandas Create With Index",
"PandasCrosstab": "Pandas Crosstab",
"PandasCummax": "Pandas Cummax",
@@ -595,13 +630,19 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasDropDuplicates": "Pandas Drop Duplicates",
"PandasDropNA": "Pandas Drop NA",
"PandasEq": "Pandas Eq",
"PandasEqScalarFloat": "Pandas Eq Scalar Float",
"PandasEqScalarInt": "Pandas Eq Scalar Int",
"PandasExp": "Pandas Exp",
"PandasFeatureSplitToNumpy": "Pandas Feature Split To Numpy",
"PandasFillNAScalarFloat": "Pandas Fill NA Scalar Float",
"PandasFillNAScalarInt": "Pandas Fill NA Scalar Int",
"PandasGe": "Pandas Ge",
"PandasGeScalarFloat": "Pandas Ge Scalar Float",
"PandasGeScalarInt": "Pandas Ge Scalar Int",
"PandasGroupBy": "Pandas Group By",
"PandasGt": "Pandas Gt",
"PandasGtScalarFloat": "Pandas Gt Scalar Float",
"PandasGtScalarInt": "Pandas Gt Scalar Int",
"PandasHead": "Pandas Head",
"PandasHorizontalConcat": "Pandas Horizontal Concat",
"PandasHorizontalSplit": "Pandas Horizontal Split",
@@ -622,6 +663,8 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasJoin": "Pandas Join",
"PandasKurtosis": "Pandas Kurtosis",
"PandasLe": "Pandas Le",
"PandasLeScalarFloat": "Pandas Le Scalar Float",
"PandasLeScalarInt": "Pandas Le Scalar Int",
"PandasLoadCSV": "Pandas Load CSV",
"PandasLoadCSVWithEncoding": "Pandas Load CSV With Encoding",
"PandasLoadCSVWithIndex": "Pandas Load CSV With Index",
@@ -633,6 +676,8 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasLocRowSeries": "Pandas Loc Row Series",
"PandasLog": "Pandas Log",
"PandasLt": "Pandas Lt",
"PandasLtScalarFloat": "Pandas Lt Scalar Float",
"PandasLtScalarInt": "Pandas Lt Scalar Int",
"PandasMax": "Pandas Max",
"PandasMean": "Pandas Mean",
"PandasMedian": "Pandas Median",
@@ -644,6 +689,8 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasMulScalarInt": "Pandas Mul Scalar Int",
"PandasMulSeries": "Pandas Mul Series",
"PandasNe": "Pandas Ne",
"PandasNeScalarFloat": "Pandas Ne Scalar Float",
"PandasNeScalarInt": "Pandas Ne Scalar Int",
"PandasPivot": "Pandas Pivot",
"PandasPow": "Pandas Pow",
"PandasPowScalarFloat": "Pandas Pow Scalar Float",
@@ -654,6 +701,7 @@ NODE_DISPLAY_NAME_MAPPINGS: Dict[str, str] = {
"PandasReplace": "Pandas Replace",
"PandasSaveCSV": "Pandas Save CSV",
"PandasSaveJSON": "Pandas Save JSON",
"PandasSelectColumnAsSeries": "Pandas Select Column As Series",
"PandasSelectColumns": "Pandas Select Columns",
"PandasSelectRows": "Pandas Select Rows",
"PandasSeriesToDataFrame": "Pandas Series To DataFrame",
docs/reference/node_reference.md
+16
View File
@@ -54,6 +54,7 @@
| [Pandas At Float](pandas_at_float.md) | Selects a cell from a pandas DataFrame and output as a Python float. |
| [Pandas At Int](pandas_at_int.md) | Selects a cell from a pandas DataFrame and output as a Python int. |
| [Pandas At String](pandas_at_string.md) | Selects a cell from a pandas DataFrame and output as a string. |
| [Pandas Boolean Index](pandas_boolean_index.md) | Selects rows from a pandas DataFrame based on the boolean index in the Series. |
| [Pandas Head](pandas_head.md) | Retrieves the first few rows of a pandas DataFrame. |
| [Pandas Iat Datetime](pandas_iat_datetime.md) | Selects a cell from a pandas DataFrame and output as a Python datetime.datetime data. |
| [Pandas Iat Float](pandas_iat_float.md) | Selects a cell from a pandas DataFrame and output as a Python float. |
@@ -65,6 +66,7 @@
| [Pandas Loc Cell String](pandas_loc_cell_string.md) | Selects a cell from a pandas DataFrame and output as a string. |
| [Pandas Loc Row MultiIndex DataFrame](pandas_loc_row_multiindex_dataframe.md) | Selects a row or rows from a pandas DataFrame with MultiIndex and output as a DataFrame. |
| [Pandas Loc Row Series](pandas_loc_row_series.md) | Selects a row from a pandas DataFrame and output as a Series. |
| [Pandas Select Column As Series](pandas_select_column_as_series.md) | Selects specific column as Series from a pandas DataFrame. |
| [Pandas Select Columns](pandas_select_columns.md) | Selects specific columns from a pandas DataFrame. |
| [Pandas Select Rows](pandas_select_rows.md) | Selects specific rows from a pandas DataFrame based on a condition. This node internally calls DataFrame.query(). |
| [Pandas Xs](pandas_xs.md) | Selects a subset of a Pandas DataFrame using specified index labels or positions. |
@@ -114,6 +116,8 @@
| [Pandas Create From Numpy](pandas_create_from_numpy.md) | Creates a pandas DataFrame from a NumPy ndarray. |
| [Pandas Create From Tensor](pandas_create_from_tensor.md) | Creates a pandas DataFrame from a PyTorch tensor. |
| [Pandas Create Series From Dict](pandas_create_series_from_dict.md) | Creates a Pandas Series from a Python dictionary. |
| [Pandas Create Series From List](pandas_create_series_from_list.md) | Creates a Pandas Series from a Python list. |
| [Pandas Create Series From List Index List](pandas_create_series_from_list_index_list.md) | Creates a Pandas Series from a Python list of cell values and a list for index. |
| [Pandas Create With Index](pandas_create_with_index.md) | Creates a pandas DataFrame using values entered in the text field. Input data is assumed to have an index. |
| [Pandas Load CSV](pandas_load_csv.md) | Loads CSV files into a pandas DataFrame. |
| [Pandas Load CSV With Encoding](pandas_load_csv_with_encoding.md) | Loads CSV files into a pandas DataFrame. |
@@ -128,11 +132,23 @@
| Node | Description |
| --- | --- |
| [Pandas Eq](pandas_eq.md) | Determines whether each element in the first pandas DataFrame is equal to the corresponding element in the second DataFrame. |
| [Pandas Eq Scalar Float](pandas_eq_scalar_float.md) | Determines whether each element in the pandas DataFrame is equal to the float. |
| [Pandas Eq Scalar Int](pandas_eq_scalar_int.md) | Determines whether each element in the pandas DataFrame is equal to the float. |
| [Pandas Ge](pandas_ge.md) | Determines whether each element in the first pandas DataFrame is greater than or equal to the corresponding element in the second DataFrame. |
| [Pandas Ge Scalar Float](pandas_ge_scalar_float.md) | Determines whether each element in the pandas DataFrame is greater than or equal to the float. |
| [Pandas Ge Scalar Int](pandas_ge_scalar_int.md) | Determines whether each element in the pandas DataFrame is greater than or equal to the int. |
| [Pandas Gt](pandas_gt.md) | Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame. |
| [Pandas Gt Scalar Float](pandas_gt_scalar_float.md) | Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame. |
| [Pandas Gt Scalar Int](pandas_gt_scalar_int.md) | Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame. |
| [Pandas Le](pandas_le.md) | Determines whether each element in the first pandas DataFrame is less than or equal to the corresponding element in the second DataFrame. |
| [Pandas Le Scalar Float](pandas_le_scalar_float.md) | Determines whether each element in the pandas DataFrame is less than or equal to the float. |
| [Pandas Le Scalar Int](pandas_le_scalar_int.md) | Determines whether each element in the pandas DataFrame is less than or equal to the int. |
| [Pandas Lt](pandas_lt.md) | Determines whether each element in the first pandas DataFrame is less than the corresponding element in the second DataFrame. |
| [Pandas Lt Scalar Float](pandas_lt_scalar_float.md) | Determines whether each element in the pandas DataFrame is less than the float. |
| [Pandas Lt Scalar Int](pandas_lt_scalar_int.md) | Determines whether each element in the pandas DataFrame is less than the int. |
| [Pandas Ne](pandas_ne.md) | Determines whether each element in the first pandas DataFrame is not equal to the corresponding element in the second DataFrame. |
| [Pandas Ne Scalar Float](pandas_ne_scalar_float.md) | Determines whether each element in the pandas DataFrame is not equal to the float. |
| [Pandas Ne Scalar Int](pandas_ne_scalar_int.md) | Determines whether each element in the pandas DataFrame is not equal to the int. |
## Math
| Node | Description |
| --- | --- |
docs/reference/pandas_boolean_index.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Boolean Index
Selects rows from a pandas DataFrame based on the boolean index in the Series.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| boolean_index_series | Series |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Data subset selection
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_create_series_from_list.md
+17
View File
@@ -0,0 +1,17 @@
# Pandas Create Series From List
Creates a Pandas Series from a Python list.
## Input
| Name | Data type |
|---|---|
| data | Pylist |
## Output
| Data type |
|---|
| Series |
<HR>
Category: IO
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_create_series_from_list_index_list.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Create Series From List Index List
Creates a Pandas Series from a Python list of cell values and a list for index.
## Input
| Name | Data type |
|---|---|
| data | Pylist |
| index | Pylist |
## Output
| Data type |
|---|
| Series |
<HR>
Category: IO
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_eq_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Eq Scalar Float
Determines whether each element in the pandas DataFrame is equal to the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_eq_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Eq Scalar Int
Determines whether each element in the pandas DataFrame is equal to the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_ge_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Ge Scalar Float
Determines whether each element in the pandas DataFrame is greater than or equal to the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_ge_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Ge Scalar Int
Determines whether each element in the pandas DataFrame is greater than or equal to the int.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_gt_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Gt Scalar Float
Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_gt_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Gt Scalar Int
Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_le_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Le Scalar Float
Determines whether each element in the pandas DataFrame is less than or equal to the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_le_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Le Scalar Int
Determines whether each element in the pandas DataFrame is less than or equal to the int.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_lt_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Lt Scalar Float
Determines whether each element in the pandas DataFrame is less than the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_lt_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Lt Scalar Int
Determines whether each element in the pandas DataFrame is less than the int.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_ne_scalar_float.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Ne Scalar Float
Determines whether each element in the pandas DataFrame is not equal to the float.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Float |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_ne_scalar_int.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Ne Scalar Int
Determines whether each element in the pandas DataFrame is not equal to the int.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| number | Int |
## Output
| Data type |
|---|
| DataFrame |
<HR>
Category: Logical operations
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
docs/reference/pandas_select_column_as_series.md
+18
View File
@@ -0,0 +1,18 @@
# Pandas Select Column As Series
Selects specific column as Series from a pandas DataFrame.
## Input
| Name | Data type |
|---|---|
| dataframe | DataFrame |
| column_name | String |
## Output
| Data type |
|---|
| Series |
<HR>
Category: Data subset selection
ComfyUI Data Analysis Node Reference. © 2025 Hide Inada (HowToSD.com). All rights reserved.
modules/cda/py_string_to_list.py
+3 -3
View File
@@ -1,4 +1,4 @@
from typing import Any, List
from typing import Any, Dict
import ast
class PyStringToList:
@@ -9,12 +9,12 @@ class PyStringToList:
"""
@classmethod
def INPUT_TYPES(cls) -> List[str]:
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the `create` function.
Returns:
List[str, Any]: A list specifying required input types.
Dict[str, Any]: A list specifying required input types.
"""
return {
"required": {
modules/pandas_wrapper/pandas_boolean_index.py
+45
View File
@@ -0,0 +1,45 @@
from typing import Any, Dict
import pandas as pd
class PandasBooleanIndex:
"""
Selects rows from a pandas DataFrame based on the boolean index in the Series.
category: Data subset selection
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"boolean_index_series": ("PDSERIES", {})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, boolean_index_series: pd.Series) -> tuple:
"""
Selects rows from a pandas DataFrame based on the boolean index in the Series.
Args:
dataframe (DataFrame): The DataFrame.
boolean_index_series: (pd.Series): The Series containing boolean index.
Returns:
tuple: A tuple containing the filtered DataFrame.
"""
if not isinstance(boolean_index_series, pd.Series):
raise ValueError("boolean_index_series is not a Series.")
df2 = dataframe[boolean_index_series]
return (df2,)
modules/pandas_wrapper/pandas_create_series_from_list.py
+49
View File
@@ -0,0 +1,49 @@
from typing import List, Any, Tuple, Dict
import pandas as pd
class PandasCreateSeriesFromList:
"""
Creates a Pandas Series from a Python list.
category: IO
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"data": ("PYLIST", {}),
}
}
RETURN_TYPES: tuple = ("PDSERIES",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, data: List[Any]) -> Tuple[pd.Series]:
"""
Creates a Pandas Series from a Python list.
Args:
data (List[Any]): A list with cell values.
Returns:
Tuple[pd.Series]: A tuple containing a Pandas Series.
Raises:
ValueError: If the data is not a list.
"""
if not isinstance(data, list):
raise ValueError("Input must be a list.")
if len(data) == 0:
return (pd.Series(),)
else:
return (pd.Series(data),)
modules/pandas_wrapper/pandas_create_series_from_list_index_list.py
+51
View File
@@ -0,0 +1,51 @@
from typing import List, Any, Tuple, Dict
import pandas as pd
class PandasCreateSeriesFromListIndexList:
"""
Creates a Pandas Series from a Python list of cell values and a list for index.
category: IO
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"data": ("PYLIST", {}),
"index": ("PYLIST", {})
}
}
RETURN_TYPES: tuple = ("PDSERIES",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, data: List[Any], index: List[Any]) -> Tuple[pd.Series]:
"""
Creates a Pandas Series from a Python list of cell values and a list for index.
Args:
data (List[Any]): A list with cell values.
index (List): A Python list containing index.
Returns:
Tuple[pd.Series]: A tuple containing a Pandas Series.
Raises:
ValueError: If the data is not a list.
"""
if not isinstance(data, list):
raise ValueError("Input must be a list.")
if len(data) == 0:
return (pd.Series(),)
else:
return (pd.Series(data, index=index),)
modules/pandas_wrapper/pandas_eq_scalar_float.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasEqScalarFloat:
"""
Determines whether each element in the pandas DataFrame is equal to the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.eq(number)
return (df_out,)
modules/pandas_wrapper/pandas_eq_scalar_int.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasEqScalarInt:
"""
Determines whether each element in the pandas DataFrame is equal to the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.eq(number)
return (df_out,)
modules/pandas_wrapper/pandas_ge_scalar_float.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasGeScalarFloat:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.ge(number)
return (df_out,)
modules/pandas_wrapper/pandas_ge_scalar_int.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasGeScalarInt:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the int.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: int) -> tuple:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the int.
Args:
dataframe (DataFrame): The DataFrame.
number (int): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.ge(number)
return (df_out,)
modules/pandas_wrapper/pandas_gt_scalar_float.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasGtScalarFloat:
"""
Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.gt(number)
return (df_out,)
modules/pandas_wrapper/pandas_gt_scalar_int.py
+44
View File
@@ -0,0 +1,44 @@
from typing import Any, Dict
import pandas as pd
class PandasGtScalarInt:
"""
Determines whether each element in the first pandas DataFrame is greater than the corresponding element in the second DataFrame.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31}
)
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: int) -> tuple:
"""
Determines whether each element in the pandas DataFrame is greater than or equal to the int.
Args:
dataframe (DataFrame): The DataFrame.
number (int): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.gt(number)
return (df_out,)
modules/pandas_wrapper/pandas_le_scalar_float.py
+44
View File
@@ -0,0 +1,44 @@
from typing import Any, Dict
import pandas as pd
class PandasLeScalarFloat:
"""
Determines whether each element in the pandas DataFrame is less than or equal to the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is less than or equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.le(number)
return (df_out,)
modules/pandas_wrapper/pandas_le_scalar_int.py
+45
View File
@@ -0,0 +1,45 @@
from typing import Any, Dict
import pandas as pd
class PandasLeScalarInt:
"""
Determines whether each element in the pandas DataFrame is less than or equal to the int.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31}
)
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: int) -> tuple:
"""
Determines whether each element in the pandas DataFrame is less than or equal to the int.
Args:
dataframe (DataFrame): The DataFrame.
number (int): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.le(number)
return (df_out,)
modules/pandas_wrapper/pandas_lt_scalar_float.py
+44
View File
@@ -0,0 +1,44 @@
from typing import Any, Dict
import pandas as pd
class PandasLtScalarFloat:
"""
Determines whether each element in the pandas DataFrame is less than the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is less than the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.lt(number)
return (df_out,)
modules/pandas_wrapper/pandas_lt_scalar_int.py
+45
View File
@@ -0,0 +1,45 @@
from typing import Any, Dict
import pandas as pd
class PandasLtScalarInt:
"""
Determines whether each element in the pandas DataFrame is less than the int.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31}
)
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: int) -> tuple:
"""
Determines whether each element in the pandas DataFrame is less than the int.
Args:
dataframe (DataFrame): The DataFrame.
number (int): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.lt(number)
return (df_out,)
modules/pandas_wrapper/pandas_ne_scalar_float.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasNeScalarFloat:
"""
Determines whether each element in the pandas DataFrame is not equal to the float.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("FLOAT", {"default": 0, "min": -2**63, "max": 2**63, "step": 0.00000001})
}
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: float) -> tuple:
"""
Determines whether each element in the pandas DataFrame is not equal to the float.
Args:
dataframe (DataFrame): The DataFrame.
number (float): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.ne(number)
return (df_out,)
modules/pandas_wrapper/pandas_ne_scalar_int.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
class PandasNeScalarInt:
"""
Determines whether each element in the pandas DataFrame is not equal to the int.
category: Logical operations
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"number": ("INT", {"default": 0, "min": -2**31, "max": 2**31}
) }
}
RETURN_TYPES: tuple = ("DATAFRAME",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, number: int) -> tuple:
"""
Determines whether each element in the pandas DataFrame is not equal to the int.
Args:
dataframe (DataFrame): The DataFrame.
number (int): The number.
Returns:
tuple: A tuple containing the DataFrame containing the result of operation.
"""
df_out = dataframe.ne(number)
return (df_out,)
modules/pandas_wrapper/pandas_select_column_as_series.py
+43
View File
@@ -0,0 +1,43 @@
from typing import Any, Dict
import pandas as pd
from .utils import column_labels_string_to_list
class PandasSelectColumnAsSeries:
"""
Selects specific column as Series from a pandas DataFrame.
category: Data subset selection
"""
@classmethod
def INPUT_TYPES(cls) -> Dict[str, Any]:
"""
Defines the input types for the function.
Returns:
Dict[str, Any]: A dictionary specifying required input types.
"""
return {
"required": {
"dataframe": ("DATAFRAME", {}),
"column_name": ("STRING", {"default": ""})
}
}
RETURN_TYPES: tuple = ("PDSERIES",)
FUNCTION: str = "f"
CATEGORY: str = "Data Analysis"
def f(self, dataframe: pd.DataFrame, column_name: str) -> tuple:
"""
Selects specific column as Series from a pandas DataFrame.
Args:
dataframe (DataFrame): The DataFrame.
column_name (str): A column name to select.
Returns:
tuple: A tuple containing the Series with selected column.
"""
series = dataframe[column_name]
return (series,)
pyproject.toml
+1 -1
View File
@@ -1,7 +1,7 @@
[project]
name = "data-analysis"
description = "Data analysis custom modules for ComfyUI – Integrates Pandas, Seaborn and Matplotlib into ComfyUI, featuring extensive PyTorch wrapper nodes for seamless tensor operations. Experimental PyTorch model training was added in v2.0."
version = "2.0.9"
version = "2.0.10"
license = {file = "LICENSE"}
[project.urls]
tests/pandas_wrapper/pandas_boolean_index_test.py
+76
View File
@@ -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()
tests/pandas_wrapper/pandas_create_series_from_list_index_list_test.py
+78
View File
@@ -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()
tests/pandas_wrapper/pandas_create_series_from_list_test.py
+65
View File
@@ -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()
tests/pandas_wrapper/pandas_eq_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_eq_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_ge_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_ge_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_gt_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_gt_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_le_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_le_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_lt_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_lt_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_ne_scalar_float_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_ne_scalar_int_test.py
+58
View File
@@ -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()
tests/pandas_wrapper/pandas_select_column_as_series_test.py
+52
View File
@@ -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()