sdg-core-lib 0.1.8.dev10__tar.gz → 0.1.9.dev0__tar.gz

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sdg-core-lib
-Version: 0.1.8.dev10
+Version: 0.1.9.dev0
 Summary: Add your description here
 Author: emiliocimino
 Author-email: emiliocimino <emilio.cimino@outlook.it>

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sdg-core-lib"
-version = "0.1.8.dev10"
+version = "0.1.9.dev0"
 description = "Add your description here"
 license = "AGPL-3.0"
 readme = "README.md"

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/src/sdg_core_lib/evaluate/base_evaluator.py

@@ -10,5 +10,5 @@ class BaseEvaluator(ABC):
         self.report = MetricReport()
 
     @abstractmethod
-    def compute(self):
+    def compute(self) -> dict:
         raise NotImplementedError

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/src/sdg_core_lib/evaluate/tables.py

@@ -34,7 +34,7 @@ class TabularComparisonEvaluator(BaseEvaluator):
             raise TypeError("synthetic_data must be a Table")
         super().__init__(real_data, synthetic_data)
 
-    def compute(self):
+    def compute(self) -> dict:
         numerical_columns = self._real_data.get_numeric_columns()
         categorical_columns = self._real_data.get_categorical_columns()
         if len(numerical_columns) < 1 and len(categorical_columns) < 1:

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/src/sdg_core_lib/evaluate/time_series.py

@@ -29,7 +29,7 @@ class TimeSeriesComparisonEvaluator(TabularComparisonEvaluator):
             raise ValueError("synthetic_data must be a TimeSeries")
         super().__init__(real_data, synthetic_data)
 
-    def compute(self):
+    def compute(self) -> dict:
         numerical_columns = self._real_data.get_numeric_columns()
         categorical_columns = self._real_data.get_categorical_columns()
         if len(numerical_columns) < 1 and len(categorical_columns) < 1:

{sdg_core_lib-0.1.8.dev10 → sdg_core_lib-0.1.9.dev0}/src/sdg_core_lib/job.py

@@ -2,7 +2,7 @@ from typing import Optional, Type
 
 from sdg_core_lib.data_generator.models.UnspecializedModel import UnspecializedModel
 from sdg_core_lib.dataset.datasets import Dataset
-from sdg_core_lib.post_process.FunctionApplier import FunctionApplier
+from sdg_core_lib.post_process.TabularFunctionApplier import TabularFunctionApplier
 from sdg_core_lib.preprocess.base_processor import Processor
 from sdg_core_lib.mappings import (
     DatasetMapping,
@@ -36,7 +36,7 @@ class Job:
         self.__dataset = dataset if dataset is not None else {}
         self.__n_rows = n_rows
         self.__save_filepath = save_filepath
-        self.__functions = functions
+        self.__functions = functions if functions else []
         dataset_type = self.__dataset.get("dataset_type", "")
         self.__dataset_mapping = self._get_dataset_mapping(dataset_type)
         self.__dataset_class = self.__dataset_mapping.get_dataset_class()
@@ -92,6 +92,36 @@ class Job:
 
         return processor
 
+    def _infer_and_evaluate(
+        self,
+        data: Dataset,
+        preprocessed_data: Dataset,
+        processor: Processor,
+        model: UnspecializedModel,
+    ) -> tuple[dict, list[dict]]:
+
+        predicted_data = model.infer(self.__n_rows)
+        synthetic_data = preprocessed_data.clone(predicted_data)
+        synthetic_data = synthetic_data.postprocess(processor)
+        function_generator = TabularFunctionApplier(
+            self.__functions, self.__n_rows, from_scratch=False
+        )
+        try:
+            filtered_synthetic_data = function_generator.apply_all(synthetic_data)
+        except TypeError:
+            filtered_synthetic_data = synthetic_data
+
+        report = {"available": "false"}
+        if data is not None:
+            evaluator = self.__evaluator_class(
+                real_data=data,
+                synthetic_data=synthetic_data,
+            )
+            report = evaluator.compute()
+
+        results = filtered_synthetic_data.to_json()
+        return report, results
+
     def train(self) -> tuple[list[dict], dict, UnspecializedModel, list[dict]]:
         """
         Runs a pre-defined training job.
@@ -117,16 +147,9 @@ class Job:
         model.train(data=preprocessed_data.get_computing_data())
         model.save(self.__save_filepath)
 
-        predicted_data = model.infer(self.__n_rows)
-        synthetic_data = preprocessed_data.clone(predicted_data)
-        synthetic_data = synthetic_data.postprocess(processor)
-
-        evaluator = self.__evaluator_class(
-            real_data=data,
-            synthetic_data=synthetic_data,
+        report, results = self._infer_and_evaluate(
+            data, preprocessed_data, processor, model
         )
-        report = evaluator.compute()
-        results = synthetic_data.to_json()
 
         return results, report, model, preprocess_schema
 
@@ -143,33 +166,22 @@ class Job:
             preprocessed_data = data.preprocess(processor)
 
         model = self._model_factory(preprocessed_data, is_new_model=False)
-        predicted_data = model.infer(self.__n_rows)
-        synthetic_data = preprocessed_data.clone(predicted_data)
-        synthetic_data = synthetic_data.postprocess(processor)
-
-        report = {"available": "false"}
-        if data is not None:
-            evaluator = self.__evaluator_class(
-                real_data=data,
-                synthetic_data=synthetic_data,
-            )
-            report = evaluator.compute()
-
-        results = synthetic_data.to_json()
+        report, results = self._infer_and_evaluate(
+            data, preprocessed_data, processor, model
+        )
 
         return results, report
 
     def generate_from_functions(self, dataset: Optional[Dataset] = None):
         """
         Generate a dataset from a list of functions.
-        :param n_rows: number of rows to generate
         :param dataset: a Dataset object
-        :return: a dataset in json format
+        :return: a dataset in JSON format
         """
         from_scratch = False
         if dataset is None:
             from_scratch = True
-        function_generator = FunctionApplier(
+        function_generator = TabularFunctionApplier(
             self.__functions, self.__n_rows, from_scratch=from_scratch
         )
         dataset = function_generator.apply_all(dataset)

sdg_core_lib-0.1.8.dev10/src/sdg_core_lib/post_process/FunctionApplier.py → sdg_core_lib-0.1.9.dev0/src/sdg_core_lib/post_process/TabularFunctionApplier.py

@@ -5,7 +5,12 @@ from loguru import logger
 from typing import Optional
 
 
-class FunctionApplier:
+class TabularFunctionApplier:
+    """
+    A class to apply functions to datasets.
+    WARNING: this class is under construction. New dataset types will be supported in the future.
+    """
+
     def __init__(
         self, function_feature_dict: list[dict], n_rows: int, from_scratch: bool = False
     ):
@@ -126,7 +131,9 @@ class FunctionApplier:
         Raises:
             ValueError: If data compatibility issues arise
         """
-        if not isinstance(dataset, Table):
+        if not type(dataset) is Table:
+            # TODO: support other dataset types
+            logger.error("Only Table datasets are currently supported")
             raise TypeError("Only Table datasets are currently supported")
 
         json_structure = dataset.to_json()