sdg-core-lib 0.1.0__py3-none-any.whl

sdg_core_lib/test/infer_test.json

@@ -0,0 +1,168 @@
+{
+	"dataset": [
+		{
+			"column_data": [
+				13.71,
+				13.4,
+				13.27,
+				13.17,
+				14.13
+			],
+			"column_name": "alcohol",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				5.65,
+				3.91,
+				4.28,
+				2.59,
+				4.1
+			],
+			"column_name": "malic_acid",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				2.45,
+				2.48,
+				2.26,
+				2.37,
+				2.74
+			],
+			"column_name": "ash",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				20.5,
+				23.0,
+				20.0,
+				20.0,
+				24.5
+			],
+			"column_name": "acl",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				95,
+				102,
+				120,
+				120,
+				96
+			],
+			"column_name": "Mmg",
+			"column_type": "continuous",
+			"column_datatype": "int64"
+		},
+		{
+			"column_data": [
+				1.68,
+				1.8,
+				1.59,
+				1.65,
+				2.05
+			],
+			"column_name": "phenols",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				0.61,
+				0.75,
+				0.69,
+				0.68,
+				0.76
+			],
+			"column_name": "flavanoids",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				0.52,
+				0.43,
+				0.43,
+				0.53,
+				0.56
+			],
+			"column_name": "nonflavanoid_phenols",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				1.06,
+				1.41,
+				1.35,
+				1.46,
+				1.35
+			],
+			"column_name": "proanth",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				7.7,
+				7.3,
+				10.2,
+				9.3,
+				9.2
+			],
+			"column_name": "color_int",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				0.64,
+				0.7,
+				0.59,
+				0.6,
+				0.61
+			],
+			"column_name": "hue",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				3.92,
+				3.4,
+				3.17,
+				3.45,
+				2.93
+			],
+			"column_name": "od",
+			"column_type": "continuous",
+			"column_datatype": "float64"
+		},
+		{
+			"column_data": [
+				740,
+				750,
+				835,
+				840,
+				560
+			],
+			"column_name": "prolin",
+			"column_type": "continuous",
+			"column_datatype": "int64"
+		}
+	],
+  	"functions_id" : [],
+	"model": {
+		"algorithm_name": "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE",
+		"model_name": "Test-T_VAE",
+        "image": "C:\\Users\\giumartine\\PycharmProjects\\SyntheticGenerator\\synthetic-data-generator\\src\\generator\\server\\saved_models\\trained_models\\Test-T_VAETabularVAE20250319.150458",
+        "input_shape": "(13,)"
+	},
+    "n_rows": 1000
+}

sdg_core_lib/test/infer_test_nodata.json

@@ -0,0 +1,77 @@
+{
+  	"behavious_id" : [],
+	"model": {
+		"algorithm_name": "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE",
+		"model_name": "Test-T_VAE",
+        "image": "./sdg_core_lib/test/outputs/",
+        "input_shape": "(13,)",
+		"training_data_info": [
+            {
+                "column_name": "alcohol",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "malic_acid",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "ash",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "acl",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "Mmg",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "phenols",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "flavanoids",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "nonflavanoid_phenols",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "proanth",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "color_int",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "hue",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "od",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            },
+            {
+                "column_name": "prolin",
+                "column_type": "continuous",
+                "column_datatype": "float64"
+            }
+        ]
+	},
+    "n_rows": 1000
+}

sdg_core_lib/test/infer_test_nodata_wrong.json

@@ -0,0 +1,11 @@
+{
+  	"behavious_id" : [],
+	"model": {
+		"algorithm_name": "sdg_core_lib.data_generator.models.keras.implementation.TabularVAE.TabularVAE",
+		"model_name": "Test-T_VAE",
+        "image": "./sdg_core_lib/test/outputs/",
+        "input_shape": "(13,)",
+		"training_data_info": []
+	},
+    "n_rows": 1000
+}

sdg_core_lib/test/post_process/functions/distribution_evaluator/implementation/test_NormalTester.py

@@ -0,0 +1,55 @@
+import pytest
+import numpy as np
+
+from sdg_core_lib.post_process.functions.distribution_evaluator.implementation.NormalTester import (
+    NormalTester,
+)
+
+
+@pytest.fixture
+def correct_instance():
+    params = [
+        {"name": "mean", "value": "0.0", "parameter_type": "float"},
+        {"name": "standard_deviation", "value": "1.0", "parameter_type": "float"},
+    ]
+    return NormalTester(parameters=params)
+
+
+def test_check_parameters(correct_instance):
+    param_mapping = {param.name: param for param in correct_instance.parameters}
+    param_names = param_mapping.keys()
+    assert param_mapping["mean"].value == 0.0
+    assert isinstance(param_mapping["mean"].value, float)
+    assert param_mapping["standard_deviation"].value == 1.0
+    assert isinstance(param_mapping["standard_deviation"].value, float)
+    assert "mean" in param_names
+    assert "standard_deviation" in param_names
+
+
+def test_compute(correct_instance):
+    data = np.random.normal(correct_instance.mean, correct_instance.std, 10000)
+    compute_data, indexes = correct_instance._compute(data)
+    assert data.shape == (10000,)
+    assert indexes.shape == (10000,)
+    assert np.all(compute_data == data)
+    assert np.all(indexes == np.array(range(len(data))))
+
+
+def test_evaluate(correct_instance):
+    correct_data = np.random.normal(correct_instance.mean, correct_instance.std, 10000)
+    assert correct_instance._evaluate(correct_data)
+
+
+def test_evaluate_wrong(correct_instance):
+    wrong_data = np.random.normal(5, 1, 10000)
+    wrong_data_2 = np.random.normal(0, 10, 10000)
+    assert not correct_instance._evaluate(wrong_data)
+    assert not correct_instance._evaluate(wrong_data_2)
+
+
+def test_get_result(correct_instance):
+    data_correct = np.random.normal(correct_instance.mean, correct_instance.std, 10000)
+    results = correct_instance.get_results(data_correct)
+    assert results["results"].shape == (10000,)
+    assert results["indexes"].shape == (10000,)
+    assert results["evaluation_results"]

sdg_core_lib/test/post_process/functions/filters/implementation/test_InnerThreshold.py

@@ -0,0 +1,30 @@
+import pytest
+
+from sdg_core_lib.post_process.functions.filter.implementation.InnerThreshold import (
+    InnerThreshold,
+)
+
+
+@pytest.fixture
+def correct_instance():
+    params = [
+        {"name": "upper_bound", "value": "50.0", "parameter_type": "float"},
+        {"name": "lower_bound", "value": "10.0", "parameter_type": "float"},
+        {"name": "upper_strict", "value": "True", "parameter_type": "bool"},
+        {"name": "lower_strict", "value": "False", "parameter_type": "bool"},
+    ]
+    return InnerThreshold(parameters=params)
+
+
+def test_check_parameters(correct_instance):
+    param_mapping = {param.name: param for param in correct_instance.parameters}
+    param_names = param_mapping.keys()
+    assert param_mapping["upper_bound"].value > param_mapping["lower_bound"].value
+    assert isinstance(param_mapping["upper_bound"].value, float)
+    assert isinstance(param_mapping["lower_bound"].value, float)
+    assert isinstance(param_mapping["upper_strict"].value, bool)
+    assert isinstance(param_mapping["lower_strict"].value, bool)
+    assert "upper_bound" in param_names
+    assert "lower_bound" in param_names
+    assert "upper_strict" in param_names
+    assert "lower_strict" in param_names

sdg_core_lib/test/pre_process/test_scaling.py

@@ -0,0 +1,55 @@
+import pytest
+import numpy as np
+
+from sdg_core_lib.preprocess.scale import (
+    standardize_simple_tabular_time_series,
+    standardize_simple_tabular_input,
+)
+
+
+@pytest.fixture()
+def correct_tabular_input():
+    return np.linspace(-10, 10, 100).reshape(10, 10)
+
+
+@pytest.fixture()
+def correct_time_series_input():
+    return np.linspace(-10, 10, 1000).reshape(10, 2, 50)
+
+
+def test_correct_tabular_scaling(correct_tabular_input):
+    scaler, standardized_train_data, standardized_test_data = (
+        standardize_simple_tabular_input(
+            train_data=correct_tabular_input, test_data=correct_tabular_input
+        )
+    )
+
+    assert type(standardized_train_data) is np.ndarray
+    assert standardized_train_data.shape == correct_tabular_input.shape
+    assert standardized_test_data.shape == correct_tabular_input.shape
+
+
+def test_incorrect_tabular_scaling(correct_time_series_input):
+    with pytest.raises(ValueError) as exception_info:
+        _, _, _ = standardize_simple_tabular_input(train_data=correct_time_series_input)
+    assert exception_info.type is ValueError
+
+
+def test_correct_time_series_scaling(correct_time_series_input):
+    scaler, standardized_train_data, standardized_test_data = (
+        standardize_simple_tabular_time_series(
+            train_data=correct_time_series_input, test_data=correct_time_series_input
+        )
+    )
+
+    assert type(standardized_train_data) is np.ndarray
+    assert standardized_train_data.shape == correct_time_series_input.shape
+    assert standardized_test_data.shape == correct_time_series_input.shape
+
+
+def test_incorrect_time_series_scaling(correct_tabular_input):
+    with pytest.raises(ValueError) as exception_info:
+        _, _, _ = standardize_simple_tabular_time_series(
+            train_data=correct_tabular_input
+        )
+    assert exception_info.type is ValueError

sdg_core_lib/test/test_browser.py

@@ -0,0 +1,11 @@
+from sdg_core_lib.browser import browse_algorithms, browse_functions
+
+
+def test_browse_algorithms():
+    for desc in browse_algorithms():
+        assert desc is not None
+
+
+def test_browse_functions():
+    for desc in browse_functions():
+        assert desc is not None

sdg_core_lib/test/test_dataset.py

@@ -0,0 +1,149 @@
+import pandas as pd
+import pytest
+import numpy as np
+
+from sdg_core_lib.NumericDataset import NumericDataset
+
+
+@pytest.fixture
+def correct_dataset():
+    return [
+        {
+            "column_name": "A",
+            "column_type": "continuous",
+            "column_datatype": "float64",
+            "column_data": [1.0, 2.0, 3.0, 4.0, 5.0],
+        },
+        {
+            "column_name": "B",
+            "column_type": "categorical",
+            "column_datatype": "object",
+            "column_data": ["a", "b", "c", "d", "e"],
+        },
+        {
+            "column_name": "C",
+            "column_type": "continuous",
+            "column_datatype": "int64",
+            "column_data": [1, 2, 3, 4, 5],
+        },
+        {
+            "column_name": "D",
+            "column_type": "test",
+            "column_datatype": "int64",
+            "column_data": [1, 2, 3, 4, 5],
+        },
+    ]
+
+
+@pytest.fixture
+def complex_dataset():
+    return [
+        {
+            "column_name": "A",
+            "column_type": "time_series",
+            "column_datatype": "float64",
+            "column_data": [[1.0, 2.0, 3.0, 4.0, 5.0], [1.0, 2.0, 3.0, 4.0, 5.0]],
+        }
+    ]
+
+
+@pytest.fixture
+def error_dataset():
+    return [
+        {
+            "column_name": "A",
+            "column_type": "categorical",
+            "column_datatype": "string",
+            "column_data": ["a", "b", "c", "d", "e"],
+        }
+    ]
+
+
+@pytest.fixture
+def empty_dataset():
+    return []
+
+
+def test_initialization(correct_dataset):
+    dataset = NumericDataset(correct_dataset)
+    assert len(dataset.columns) == 4
+    assert len(dataset.categorical_columns) == 1
+    assert len(dataset.continuous_columns) == 2
+    assert len(dataset.unrecognized_columns) == 1
+    assert dataset.get_numpy_data(dataset.dataframe).shape == (5, 4)
+
+
+def test_dataset_complexity(complex_dataset):
+    dataset = NumericDataset(complex_dataset)
+    print(np.array(dataset.dataframe.to_numpy().tolist()).shape)
+    assert len(dataset.columns) == 1
+    assert len(dataset.categorical_columns) == 0
+    assert len(dataset.continuous_columns) == 0
+    assert len(dataset.unrecognized_columns) == 1
+    assert dataset.get_numpy_data(dataset.dataframe).shape == (2, 1, 5)
+
+
+def test_error_initialization(error_dataset):
+    with pytest.raises(TypeError) as exception_info:
+        _ = NumericDataset(error_dataset)
+    assert exception_info.type is TypeError
+
+
+def test_parse_tabular_data_json(correct_dataset):
+    dataset = NumericDataset(correct_dataset)
+    print(dataset.dataframe["A"].dtype)
+    list_dict = dataset.parse_tabular_data_json()
+    assert len(list_dict) == len(dataset.columns)
+    assert list_dict[0]["column_name"] == "A"
+    assert list_dict[0]["column_type"] == "continuous"
+    assert list_dict[0]["column_datatype"] == "float64"
+    assert list_dict[0]["column_data"] == [1, 2, 3, 4, 5]
+    assert list_dict[1]["column_name"] == "B"
+    assert list_dict[1]["column_type"] == "categorical"
+    assert list_dict[1]["column_datatype"] == "object"
+    assert list_dict[1]["column_data"] == ["a", "b", "c", "d", "e"]
+    assert list_dict[2]["column_name"] == "C"
+    assert list_dict[2]["column_type"] == "continuous"
+    assert list_dict[2]["column_datatype"] == "int64"
+    assert list_dict[2]["column_data"] == [1, 2, 3, 4, 5]
+    assert list_dict[3]["column_name"] == "D"
+    assert list_dict[3]["column_type"] == "none"
+    assert list_dict[3]["column_datatype"] == "int64"
+    assert list_dict[3]["column_data"] == [1, 2, 3, 4, 5]
+
+
+def test_parse_data_to_registry(correct_dataset):
+    dataset = NumericDataset(correct_dataset)
+    feature_list = dataset.parse_data_to_registry()
+    assert len(feature_list) == len(dataset.columns)
+    assert feature_list[0]["feature_name"] == "A"
+    assert feature_list[0]["feature_position"] == 0
+    assert feature_list[0]["is_categorical"] is False
+    assert feature_list[0]["type"] == "float64"
+    assert feature_list[1]["feature_name"] == "B"
+    assert feature_list[1]["feature_position"] == 1
+    assert feature_list[1]["is_categorical"] is True
+    assert feature_list[1]["type"] == "object"
+    assert feature_list[2]["feature_name"] == "C"
+    assert feature_list[2]["feature_position"] == 2
+    assert feature_list[2]["is_categorical"] is False
+    assert feature_list[2]["type"] == "int64"
+    assert feature_list[3]["feature_name"] == "D"
+    assert feature_list[3]["feature_position"] == 3
+    assert feature_list[3]["is_categorical"] is False
+    assert feature_list[3]["type"] == "int64"
+
+
+def test_get_data(correct_dataset):
+    dataset = NumericDataset(correct_dataset)
+    dataframe, columns, continuous_columns, categorical_columns = dataset.get_data()
+    assert type(dataframe) is pd.DataFrame
+    assert columns == ["A", "B", "C", "D"]
+    assert continuous_columns == ["A", "C"]
+    assert categorical_columns == ["B"]
+
+
+def test_empty_dataset(empty_dataset):
+    with pytest.raises(ValueError) as exception_info:
+        _ = NumericDataset(empty_dataset)
+    assert exception_info.type is ValueError