From 89a01660e6c729013c0d975abd1f0ea5dff94570 Mon Sep 17 00:00:00 2001 From: Spiros Maggioros Date: Mon, 9 Dec 2024 18:30:38 +0200 Subject: [PATCH] Fixed pre-commit | Minor code changes --- merge_ROI_demo_and_test.py | 97 ----------------------- spare_scores/cli.py | 4 +- spare_scores/data_prep.py | 2 +- spare_scores/util.py | 4 +- tests/conftest.py | 25 ------ tests/unit/test_data_prep.py | 123 ++++++++++++++++------------- tests/unit/test_spare_scores.py | 134 +++++++++++++------------------- tests/unit/test_util.py | 28 +++---- 8 files changed, 143 insertions(+), 274 deletions(-) delete mode 100644 merge_ROI_demo_and_test.py delete mode 100644 tests/conftest.py diff --git a/merge_ROI_demo_and_test.py b/merge_ROI_demo_and_test.py deleted file mode 100644 index 7f85d8d..0000000 --- a/merge_ROI_demo_and_test.py +++ /dev/null @@ -1,97 +0,0 @@ -import argparse - -import pandas as pd - -from spare_scores import spare_test - - -def merge_and_test( - roi_file, - demographic_file, - model_path, - key_var, - output_file, - spare_column_name, - verbose, - logs_file, -): - - # Read the input CSV files into pandas DataFrames - df_roi = pd.read_csv(roi_file) - df_demographic = pd.read_csv(demographic_file) - - # Merge the DataFrames based on the desired column - if not key_var: - key_var = df_roi.columns[0] - merged_df = pd.merge(df_roi, df_demographic, on=key_var) - - # Call the spare_test function from the spare_scores package - result = spare_test( - merged_df, - model_path, - key_var, - output_file, - spare_column_name, - verbose, - logs_file, - ) - - return result - - -if __name__ == "__main__": - # Example usage: - # python merge_ROI_demo_and_test.py -i spare_scores/data/example_data_ROIs.csv \ - # -d spare_scores/data/example_data_demographics.csv \ - # -m spare_scores/mdl/mdl_SPARE_AD_hMUSE_single.pkl.gz \ - # -kv ID \ - # -o zzz_output.csv \ - # -l zzz_logs.txt \ - # -sv SPARE_score - # # Create an ArgumentParser object - parser = argparse.ArgumentParser(description="Spare Scores Analysis") - - # Define the command-line arguments - parser.add_argument("-i", "--input", required=True, help="Input ROI CSV file") - parser.add_argument( - "-d", "--demographic", required=True, help="Input demographic CSV file" - ) - parser.add_argument("-m", "--model", required=True, help="Model for spare_train") - parser.add_argument( - "-kv", - "--key_var", - required=False, - default="", - help="The key variable of the dataset.", - ) - parser.add_argument( - "-o", "--output", required=False, default="", help="Output CSV file" - ) - parser.add_argument( - "-l", "--logs", required=False, default="", help="Output logs file" - ) - parser.add_argument( - "-sv", - "--spare_var", - required=False, - default="SPARE_score", - help="Column for calculated spare score", - ) - parser.add_argument( - "-v", "--verbose", required=False, default=1, help="Type of logging messages." - ) - - # Parse the command-line arguments - args = parser.parse_args() - - # Call the merge_and_test function with the provided arguments - merge_and_test( - args.input, - args.demographic, - args.model, - args.key_var, - args.output, - args.spare_var, - args.verbose, - args.logs, - ) diff --git a/spare_scores/cli.py b/spare_scores/cli.py index cf80d2b..7ad8ce0 100644 --- a/spare_scores/cli.py +++ b/spare_scores/cli.py @@ -1,10 +1,8 @@ import argparse - -import pkg_resources # type: ignore +from importlib.metadata import version from .spare import spare_test, spare_train -from importlib.metadata import version VERSION = version("spare_scores") diff --git a/spare_scores/data_prep.py b/spare_scores/data_prep.py index a7e3127..d44619f 100644 --- a/spare_scores/data_prep.py +++ b/spare_scores/data_prep.py @@ -275,7 +275,7 @@ def age_sex_match( df1, df2 = df1[df1[to_match] == grps[0]], df1[df1[to_match] == grps[1]] no_df2 = True else: - if to_match is not None: + if to_match != "": logging.info('Two dataframes provided. "to_match" will be ignored.') no_df2 = False diff --git a/spare_scores/util.py b/spare_scores/util.py index 9e47915..ba0d48c 100644 --- a/spare_scores/util.py +++ b/spare_scores/util.py @@ -2,7 +2,7 @@ import logging import os import pickle -from typing import Any, Union +from typing import Any, Optional, Union import numpy as np import pandas as pd @@ -43,7 +43,7 @@ def add_file_extension(filename: str, extension: str) -> str: return filename -def check_file_exists(filename: str, logger: Any) -> Any: +def check_file_exists(filename: Optional[str], logger: Any) -> Any: """ Checks if file exists diff --git a/tests/conftest.py b/tests/conftest.py deleted file mode 100644 index 4d4aec1..0000000 --- a/tests/conftest.py +++ /dev/null @@ -1,25 +0,0 @@ -import gzip -import pickle -from pathlib import Path - -import pandas as pd -import pytest - - -@pytest.fixture -def df_fixture(): - # Load the sample data from the fixture - data_path = Path(__file__).resolve().parent / "fixtures" / "sample_data.csv" - data_path = str(data_path) - return pd.read_csv(data_path) - - -@pytest.fixture -def model_fixture(): - # Load the sample model from the fixture - # This model was created using this package based on the above (randomly - # generated data) - model_path = Path(__file__).resolve().parent / "fixtures" / "sample_model.pkl.gz" - with gzip.open(model_path, "rb") as f: - model = pickle.load(f) - return model diff --git a/tests/unit/test_data_prep.py b/tests/unit/test_data_prep.py index 8f07ac0..0fd0fcb 100644 --- a/tests/unit/test_data_prep.py +++ b/tests/unit/test_data_prep.py @@ -16,24 +16,26 @@ class CheckDataPrep(unittest.TestCase): - def test_check_train(self): + def test_check_train(self) -> None: # Test case 1: Valid input dataframe and predictors self.df_fixture = load_df("../fixtures/sample_data.csv") predictors = ["ROI1", "ROI2", "ROI3"] to_predict = "Sex" pos_group = "M" - filtered_df, filtered_predictors, mdl_type = check_train( - self.df_fixture, predictors, to_predict, pos_group=pos_group - ) - self.assertTrue( - filtered_df.equals(self.df_fixture) - ) # Check if filtered dataframe is the same as the input dataframe - self.assertTrue( - filtered_predictors == predictors - ) # Check if filtered predictors are the same as the input predictors - self.assertTrue( - mdl_type == "Classification" - ) # Check if the SPARE model type is correct + res = check_train(self.df_fixture, predictors, to_predict, pos_group=pos_group) + + if isinstance(res, tuple) and len(res) == 3: + filtered_df, filtered_predictors, mdl_type = res + + self.assertTrue( + filtered_df.equals(self.df_fixture) + ) # Check if filtered dataframe is the same as the input dataframe + self.assertTrue( + filtered_predictors == predictors + ) # Check if filtered predictors are the same as the input predictors + self.assertTrue( + mdl_type == "Classification" + ) # Check if the SPARE model type is correct # Test case 2: Missing required columns df_missing_columns = pd.DataFrame( @@ -42,8 +44,12 @@ def test_check_train(self): predictors = ["Var1", "Var2"] to_predict = "ToPredict" pos_group = "1" - res = check_train(df_missing_columns, predictors, to_predict, pos_group) - self.assertTrue(res == "Variable to predict is not in the input dataframe.") + verbose = 1 + res = check_train( + df_missing_columns, predictors, to_predict, verbose, pos_group + ) + if isinstance(res, str): + self.assertTrue(res == "Variable to predict is not in the input dataframe.") # Test case 3: Predictor not in input dataframe df = pd.DataFrame( @@ -57,10 +63,13 @@ def test_check_train(self): predictors = ["Var1", "Var2"] # Var2 is not in the input dataframe to_predict = "ToPredict" pos_group = "1" - res = check_train(df, predictors, to_predict, pos_group) - self.assertTrue(res == "Not all predictors exist in the input dataframe.") + verbose = 1 + res = check_train(df, predictors, to_predict, verbose, pos_group) - def test_check_test(self): + if isinstance(res, str): + self.assertTrue(res == "Not all predictors exist in the input dataframe.") + + def test_check_test(self) -> None: # Test case 1: Valid input dataframe and meta_data df = pd.DataFrame( { @@ -121,9 +130,9 @@ def test_check_test(self): ), } res = check_test(df_age_outside_range, meta_data) - self.assertTrue(res[1] == None) + self.assertTrue(res[1] is None) - def test_smart_unique(self): + def test_smart_unique(self) -> None: # test case 1: testing smart_unique with df2=None, to_predict=None self.df_fixture = load_df("../fixtures/sample_data.csv") result = smart_unique(self.df_fixture, None) @@ -141,13 +150,17 @@ def test_smart_unique(self): } self.df_fixture = pd.DataFrame(data=df) result = smart_unique(self.df_fixture, None, to_predict="ROI1") - err_msg = "Variable to predict has no variance." - self.assertTrue(result == err_msg) + + if isinstance(result, str): + err_msg = "Variable to predict has no variance." + self.assertTrue(result == err_msg) # test case 3: testing smart_unique with variance and no duplicate ID's. df2=None self.df_fixture = load_df("../fixtures/sample_data.csv") result = smart_unique(self.df_fixture, None, "ROI1") - self.assertTrue(result.equals(self.df_fixture)) + + if isinstance(result, pd.DataFrame): + self.assertTrue(result.equals(self.df_fixture)) # test case 4: testing smart_unique with variance and duplicate ID's. df2=None self.df_fixture = pd.DataFrame(data=df) @@ -162,31 +175,33 @@ def test_smart_unique(self): } self.df_fixture = self.df_fixture._append(new_row, ignore_index=True) result = smart_unique(self.df_fixture, None, "ROI1") - correct_df = { - "Id": [1.0, 2.0, 3.0, 4.0, 5.0, float("nan")], - "ScanID": [ - "Scan001", - "Scan002", - "Scan003", - "Scan004", - "Scan005", - "Scan006", - ], - "Age": [35, 40, 45, 31, 45, 45], - "Sex": ["M", "F", "F", "M", "F", "F"], - "ROI1": [0.64, 0.64, 0.64, 0.64, 0.64, 0.84], - "ROI2": [0.73, 0.91, 0.64, 0.76, 0.78, 0.73], - "ID": [ - float("nan"), - float("nan"), - float("nan"), - float("nan"), - float("nan"), - 5.0, - ], - } - correct_df = pd.DataFrame(data=correct_df) - self.assertTrue(result.equals(correct_df)) + + if isinstance(result, pd.DataFrame): + correct_df = { + "Id": [1.0, 2.0, 3.0, 4.0, 5.0, float("nan")], + "ScanID": [ + "Scan001", + "Scan002", + "Scan003", + "Scan004", + "Scan005", + "Scan006", + ], + "Age": [35, 40, 45, 31, 45, 45], + "Sex": ["M", "F", "F", "M", "F", "F"], + "ROI1": [0.64, 0.64, 0.64, 0.64, 0.64, 0.84], + "ROI2": [0.73, 0.91, 0.64, 0.76, 0.78, 0.73], + "ID": [ + float("nan"), + float("nan"), + float("nan"), + float("nan"), + float("nan"), + 5.0, + ], + } + correct_df = pd.DataFrame(data=correct_df) + self.assertTrue(result.equals(correct_df)) # test case 5: testing df2 != None and no_df2=False df1 = { @@ -199,10 +214,10 @@ def test_smart_unique(self): self.df_fixture1 = pd.DataFrame(data=df1) self.df_fixture2 = pd.DataFrame(data=df2) - result = smart_unique(self.df_fixture1, self.df_fixture2, to_predict=None) + result = smart_unique(self.df_fixture1, self.df_fixture2, to_predict="") self.assertTrue(result == (self.df_fixture1, self.df_fixture2)) - def test_age_sex_match(self): + def test_age_sex_match(self) -> None: # test case 1: testing df2=None and to_match=None self.df_fixture = load_df("../fixtures/sample_data.csv") result = age_sex_match(self.df_fixture, None) @@ -220,7 +235,7 @@ def test_age_sex_match(self): self.df_fixture1 = load_df("../fixtures/sample_data.csv") self.df_fixture2 = self.df_fixture1 result = age_sex_match( - self.df_fixture1, self.df_fixture2, to_match=None, age_out_percentage=150 + self.df_fixture1, self.df_fixture2, to_match="", age_out_percentage=150 ) # Now no_df2=False err_msg = "Age-out-percentage must be between 0 and 100" self.assertTrue(result == err_msg) @@ -237,7 +252,7 @@ def test_age_sex_match(self): self.df_fixture1 = pd.DataFrame(data=df1) self.df_fixture2 = self.df_fixture1 result = age_sex_match( - self.df_fixture1, self.df_fixture2, to_match=None + self.df_fixture1, self.df_fixture2, to_match="" ) # here sex_match=False self.assertTrue(result == (self.df_fixture1, self.df_fixture2)) @@ -265,7 +280,7 @@ def test_age_sex_match(self): print(result) self.assertTrue(result.equals(correct_df)) - def test_logging_basic_config(self): + def test_logging_basic_config(self) -> None: logging_level = { 0: logging.WARNING, 1: logging.INFO, @@ -291,5 +306,5 @@ def test_logging_basic_config(self): self.assertTrue(os.path.exists("test_data_prep.py")) self.assertTrue(result == logging.getLogger()) - def test_convert_cat_variables(self): + def test_convert_cat_variables(self) -> None: pass diff --git a/tests/unit/test_spare_scores.py b/tests/unit/test_spare_scores.py index bcbf974..aacb96a 100644 --- a/tests/unit/test_spare_scores.py +++ b/tests/unit/test_spare_scores.py @@ -1,22 +1,25 @@ +import os import unittest from pathlib import Path + import numpy as np import pandas as pd -import os + from spare_scores.data_prep import check_test -from spare_scores.util import load_df, load_model from spare_scores.mlp_torch import MLPDataset from spare_scores.spare import spare_test, spare_train +from spare_scores.util import load_df, load_model + class CheckMLPDataset(unittest.TestCase): - def test_len(self): + def test_len(self) -> None: # test case 1: testing length self.X = np.array([1, 2, 3, 4, 5, 6, 7, 8]) self.Y = np.array([1, 2, 3, 4, 5, 6, 7, 8]) self.Dataset = MLPDataset(self.X, self.Y) self.assertTrue(len(self.Dataset) == 8) - def test_idx(self): + def test_idx(self) -> None: # test case 2: testing getter self.X = np.array([1, 2, 3, 4, 5, 6, 7, 8]) self.Y = np.array([1, 2, 3, 4, 5, 6, 7, 8]) @@ -24,15 +27,16 @@ def test_idx(self): self.assertTrue(self.Dataset[0] == (1, 1)) self.assertTrue(self.Dataset[len(self.Dataset) - 1] == (8, 8)) + class CheckSpareScores(unittest.TestCase): - def test_spare_test_SVM(self): + def test_spare_test_SVM(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") self.model_fixture = load_model("../fixtures/sample_model.pkl.gz") # Test case 1: Test with df result = spare_test(self.df_fixture, self.model_fixture) - status_code, status, result = ( + _, status, result = ( result["status_code"], result["status"], result["data"], @@ -46,8 +50,8 @@ def test_spare_test_SVM(self): filepath = ( Path(__file__).resolve().parent.parent / "fixtures" / "sample_data.csv" ) - filepath = str(filepath) - result = spare_test(filepath, self.model_fixture) + new_filepath = str(filepath) + result = spare_test(new_filepath, self.model_fixture) status, result = result["status"], result["data"] self.assertTrue(status == "OK") self.assertTrue(isinstance(result, pd.DataFrame)) @@ -69,7 +73,7 @@ def test_spare_test_SVM(self): ) self.assertTrue(result == ["ROI1"]) - def test_spare_train_MLP(self): + def test_spare_train_MLP(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") self.model_fixture = load_model("../fixtures/sample_model.pkl.gz") # Test case 1: Testing spare_train with MLP model @@ -105,7 +109,7 @@ def test_spare_train_MLP(self): self.df_fixture, "ROI1", model_type="MLP", - data_vars = [ + data_vars=[ "ROI2", "ROI3", "ROI4", @@ -114,8 +118,8 @@ def test_spare_train_MLP(self): "ROI7", "ROI8", "ROI9", - "ROI10" - ] + "ROI10", + ], ) status, result_data = result["status"], result["data"] metadata = result_data[1] @@ -124,7 +128,7 @@ def test_spare_train_MLP(self): self.assertTrue(metadata["kernel"] == "linear") # self.assertTrue(metadata["to_predict"] == "to_predict") - def test_spare_train_MLPTorch(self): + def test_spare_train_MLPTorch(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") self.model_fixture = load_model("../fixtures/sample_model.pkl.gz") # Test case 1: testing training an MLPTorch model @@ -162,7 +166,7 @@ def test_spare_train_MLPTorch(self): self.df_fixture, "ROI1", model_type="MLPTorch", - data_vars = [ + data_vars=[ "ROI2", "ROI3", "ROI4", @@ -172,7 +176,7 @@ def test_spare_train_MLPTorch(self): "ROI8", "ROI9", "ROI10", - ] + ], ) status, result_data = result["status"], result["data"] metadata = result_data[1] @@ -181,7 +185,7 @@ def test_spare_train_MLPTorch(self): self.assertTrue(metadata["kernel"] == "linear") # self.assertTrue(metadata["to_predict"] == "to_predict") - def test_spare_train_SVM(self): + def test_spare_train_SVM(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") self.model_fixture = load_model("../fixtures/sample_model.pkl.gz") @@ -222,7 +226,7 @@ def test_spare_train_SVM(self): result = spare_train( self.df_fixture, "ROI1", - data_vars = [ + data_vars=[ "ROI2", "ROI3", "ROI4", @@ -231,8 +235,8 @@ def test_spare_train_SVM(self): "ROI7", "ROI8", "ROI9", - "ROI10" - ] + "ROI10", + ], ) status, result_data = result["status"], result["data"] metadata = result_data[1] @@ -241,24 +245,16 @@ def test_spare_train_SVM(self): self.assertTrue(metadata["kernel"] == "linear") # self.assertTrue(metadata["to_predict"] == "to_predict") - def test_spare_train_SVM_None(self): + def test_spare_train_SVM_None(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") # Test case 1: Training with no data vars - result = spare_train( - self.df_fixture, - "Age" - ) + result = spare_train(self.df_fixture, "Age") self.assertTrue(result is not None) - - def test_spare_train_SVM2(self): + def test_spare_train_SVM2(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") # Test case 1: Test overwrites - result = spare_train( - self.df_fixture, - "Age", - output="test_util.py" - ) + result = spare_train(self.df_fixture, "Age", output="test_util.py") self.assertTrue(result["status_code"] == 2) # Test case 2: Train with non existing output file @@ -277,12 +273,12 @@ def test_spare_train_SVM2(self): "ROI9", "ROI10", ], - output="results" + output="results", ) - self.assertTrue(os.path.isfile("results.pkl.gz") == True) + self.assertTrue(os.path.isfile("results.pkl.gz") is True) os.remove("results.pkl.gz") - def test_spare_train_non_existing_model(self): + def test_spare_train_non_existing_model(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") # Test case 1: training with non existing model type result = spare_train( @@ -304,13 +300,13 @@ def test_spare_train_non_existing_model(self): ) self.assertTrue(result["status_code"] == 2) - def test_spare_test_exceptions(self): + def test_spare_test_exceptions(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") self.model_fixture = load_model("../fixtures/sample_model.pkl.gz") # Test case 1: Test with existing output path - if(not os.path.isfile("output.csv")): - f = open("output.csv", "x") + if not os.path.isfile("output.csv"): + _ = open("output.csv", "x") result = spare_test(self.df_fixture, self.model_fixture, output="output") self.assertTrue(result["status_code"] == 0) os.remove("output.csv") @@ -319,18 +315,15 @@ def test_spare_test_exceptions(self): data = { "Var1": [x for x in range(100)], "Var2": [x for x in range(100)], - "label": [x**2 for x in range(100)] + "label": [x**2 for x in range(100)], } self.df_fixture = pd.DataFrame(data=data) - meta_data = { - "predictors": "Not_existing" - } + meta_data = {"predictors": "Not_existing"} err, cols_not_found = check_test(self.df_fixture, meta_data) self.assertTrue(len(err) != 0) self.assertTrue(cols_not_found is not None) - - def test_spare_train_regression_error(self): + def test_spare_train_regression_error(self) -> None: self.df_fixture = load_df("../fixtures/sample_data.csv") # Test case 1: testing with non-integer like as predictor result = spare_train( @@ -347,65 +340,50 @@ def test_spare_train_regression_error(self): "ROI8", "ROI9", "ROI10", - ] + ], ) self.assertTrue(result["status_code"] == 2) - self.assertTrue(result["status"] == "Dataset check failed before training was initiated.") + self.assertTrue( + result["status"] == "Dataset check failed before training was initiated." + ) # Test case 2: testing with a too-small dataset data = { - "Var1": [1,2,3,4,5], - "Var2": [2,4,6,8,10], - "label": [1.5,2.4,3.2,4.5,5.5] + "Var1": [1, 2, 3, 4, 5], + "Var2": [2, 4, 6, 8, 10], + "label": [1.5, 2.4, 3.2, 4.5, 5.5], } self.df_fixture = pd.DataFrame(data=data) - result = spare_train( - self.df_fixture, - "label", - data_vars=[ - "Var1", - "Var2" - ] - ) + result = spare_train(self.df_fixture, "label", data_vars=["Var1", "Var2"]) self.assertTrue(result["status_code"] == 2) - self.assertTrue(result["status"] == "Dataset check failed before training was initiated.") + self.assertTrue( + result["status"] == "Dataset check failed before training was initiated." + ) # Test case 3: testing with a label that has to variance data = { - "Var1": [1,2,3,4,5], - "Var2": [2,4,6,8,10], - "label": [1,1,1,1,1] + "Var1": [1, 2, 3, 4, 5], + "Var2": [2, 4, 6, 8, 10], + "label": [1, 1, 1, 1, 1], } self.df_fixture = pd.DataFrame(data=data) - result = spare_train( - self.df_fixture, - "label", - data_vars=[ - "Var1", - "Var2" - ] - ) + result = spare_train(self.df_fixture, "label", data_vars=["Var1", "Var2"]) self.assertTrue(result["status_code"] == 2) - self.assertTrue(result["status"] == "Dataset check failed before training was initiated.") + self.assertTrue( + result["status"] == "Dataset check failed before training was initiated." + ) # Test case 4: testing with a dataset that may be too small data = { "Var1": [x for x in range(80)], "Var2": [x for x in range(80)], "Var3": [x for x in range(80)], - "label": [x*2 for x in range(80)] + "label": [x * 2 for x in range(80)], } self.df_fixture = pd.DataFrame(data=data) - result = spare_train( - self.df_fixture, - "label", - data_vars=[ - "Var1", - "Var2" - ] - ) + result = spare_train(self.df_fixture, "label", data_vars=["Var1", "Var2"]) self.assertTrue(result is not None) diff --git a/tests/unit/test_util.py b/tests/unit/test_util.py index 7512b3d..f22d3de 100644 --- a/tests/unit/test_util.py +++ b/tests/unit/test_util.py @@ -20,15 +20,15 @@ class CheckSpareScoresUtil(unittest.TestCase): - def test_load_model(self): + def test_load_model(self) -> None: self.model_fixture = load_model("../../tests/fixtures/sample_model.pkl.gz") # Test case 1: Load a model filepath = ( Path(__file__).resolve().parent.parent / "fixtures" / "sample_model.pkl.gz" ) - filepath = str(filepath) - result = load_model(filepath) + new_filepath = str(filepath) + result = load_model(new_filepath) self.assertTrue(result[1]["mdl_type"] == self.model_fixture[1]["mdl_type"]) self.assertTrue(result[1]["kernel"] == self.model_fixture[1]["kernel"]) self.assertTrue(result[1]["predictors"] == self.model_fixture[1]["predictors"]) @@ -38,7 +38,7 @@ def test_load_model(self): == self.model_fixture[1]["categorical_var_map"] ) - def test_expspace(self): + def test_expspace(self) -> None: # Test case 1: span = [0, 2] span = [0, 2] expected_result = np.array([1.0, 2.71828183, 7.3890561]) @@ -56,7 +56,7 @@ def test_expspace(self): expected_result = np.array([0.13533528, 0.36787944, 1.0, 2.71828183]) self.assertTrue(np.allclose(expspace(span), expected_result)) - def test_check_file_exists(self): + def test_check_file_exists(self) -> None: # test case 1: filename=None logger = logging.getLogger(__name__) result = check_file_exists(None, logger) @@ -71,7 +71,7 @@ def test_check_file_exists(self): err_msg = "The output filename test_util.py, corresponds to an existing file, interrupting execution to avoid overwrite." self.assertTrue(result == err_msg) - def test_save_file(self): + def test_save_file(self) -> None: # test case 1: testing training output file that don't exist result = pd.DataFrame( data={ @@ -95,7 +95,7 @@ def test_save_file(self): self.assertTrue(os.path.exists(output + ".csv")) os.remove(output + ".csv") - def test_is_unique_identifier(self): + def test_is_unique_identifier(self) -> None: # test case 1: testing with a unique identifier df = { "ID": [0, 1, 2, 3, 4], @@ -117,7 +117,7 @@ def test_is_unique_identifier(self): self.df_fixture = pd.DataFrame(data=df) self.assertFalse(is_unique_identifier(self.df_fixture, ["Var1", "Var2"])) - def test_load_examples(self): + def test_load_examples(self) -> None: # test case 1: testing loading example csv file_name = "example_data.csv" result = load_examples(file_name) @@ -133,7 +133,7 @@ def test_load_examples(self): result = load_examples(file_name) self.assertTrue(result is None) - def test_convert_to_number_if_possible(self): + def test_convert_to_number_if_possible(self) -> None: # test case 1: valid convertion to integer num = "254" self.assertTrue(convert_to_number_if_possible(num) == 254) @@ -142,14 +142,14 @@ def test_convert_to_number_if_possible(self): num = "CBICA" self.assertTrue(convert_to_number_if_possible(num) == num) - def test_load_df(self): + def test_load_df(self) -> None: # Test case 1: Input is a string (CSV file path) filepath = ( Path(__file__).resolve().parent.parent / "fixtures" / "sample_data.csv" ) - filepath = str(filepath) - expected_df = pd.read_csv(filepath, low_memory=False) - self.assertTrue(load_df(filepath).equals(expected_df)) + new_filepath = str(filepath) + expected_df = pd.read_csv(new_filepath, low_memory=False) + self.assertTrue(load_df(new_filepath).equals(expected_df)) # Test case 2: Input is already a DataFrame input_df = pd.DataFrame({"A": [1, 2, 3], "B": [4, 5, 6]}) @@ -166,7 +166,7 @@ def test_load_df(self): expected_df = input_df.copy() self.assertTrue(load_df(input_df).equals(expected_df)) - def test_add_file_extension(self): + def test_add_file_extension(self) -> None: # Test case 1: File extension already present filename = "myfile.txt" extension = ".txt"