From b147602f883ed8025f6787f84529328453ae0714 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 19:18:04 +0100
Subject: [PATCH 01/10] add logger

---
 src/ydata_quality/utils/logger.py | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 src/ydata_quality/utils/logger.py

diff --git a/src/ydata_quality/utils/logger.py b/src/ydata_quality/utils/logger.py
new file mode 100644
index 00000000..24a2474e
--- /dev/null
+++ b/src/ydata_quality/utils/logger.py
@@ -0,0 +1,25 @@
+import logging
+from typing import TextIO
+import sys
+import os
+
+# Default vars for the logger
+NAME = os.getenv('DQ_LOGGER_NAME', 'DQ_Logger')
+STREAM = sys.stdout
+LOG_LEVEL = os.getenv('DQ_LOG_LEVEL', logging.WARNING)
+
+def create_logger(name, stream: TextIO = sys.stdout, level=logging.INFO):
+  handler = logging.StreamHandler(stream)
+  handler.setFormatter(
+      logging.Formatter(
+          "%(levelname)s | %(message)s"
+      )
+  )
+
+  logger = logging.getLogger(name)
+  logger.setLevel(level)
+  if len(logger.handlers)==0:
+    logger.addHandler(handler)
+  logger.propagate = False
+
+  return logger

From 2a2296eb24f486734d997e9f6504e20e1202def9 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 19:19:18 +0100
Subject: [PATCH 02/10] change target to label in modelling

---
 src/ydata_quality/utils/modelling.py | 27 ++++++++++++++-------------
 1 file changed, 14 insertions(+), 13 deletions(-)

diff --git a/src/ydata_quality/utils/modelling.py b/src/ydata_quality/utils/modelling.py
index ae8eb71c..b1d62810 100644
--- a/src/ydata_quality/utils/modelling.py
+++ b/src/ydata_quality/utils/modelling.py
@@ -21,6 +21,7 @@
 from sklearn.utils._testing import ignore_warnings
 
 from ydata_quality.utils.enum import PredictionTask
+from ydata_quality.utils.auxiliary import infer_dtypes
 
 BASELINE_CLASSIFIER = Pipeline([
     ('imputer', SimpleImputer()),
@@ -51,17 +52,17 @@ def get_prediction_task(df: pd.DataFrame, label: str):
         return 'regression'
 
 @ignore_warnings(category=ConvergenceWarning)
-def baseline_predictions(df: pd.DataFrame, target: str, task='classification'):
+def baseline_predictions(df: pd.DataFrame, label: str, task='classification'):
     "Train a baseline model and predict for a test set"
 
     # 0. Infer the prediction task
-    task = get_prediction_task(df=df, label=target)
+    task = get_prediction_task(df=df, label=label)
 
     # 1. Define the baseline model
     model = BASELINE_CLASSIFIER if task == 'classification' else BASELINE_REGRESSION
 
     # 2. Train overall model
-    X, y = df.drop(target, axis=1), label_binarize(df[target], classes=list(set(df[target])))
+    X, y = df.drop(label, axis=1), label_binarize(df[label], classes=list(set(df[label])))
     X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
     model.fit(X_train.select_dtypes('number'), y_train)
 
@@ -75,26 +76,26 @@ def baseline_predictions(df: pd.DataFrame, target: str, task='classification'):
     return y_pred, X_test, y_test
 
 @ignore_warnings(category=DataConversionWarning)
-def baseline_performance(df: pd.DataFrame, target: str,
+def baseline_performance(df: pd.DataFrame, label: str,
                         task: PredictionTask = PredictionTask.CLASSIFICATION,
                         adjusted_metric: bool = False):
     """Train a baseline model, predict for a test set and return the performance.
 
     Args:
         - df (pd.DataFrame): original dataset
-        - target (str): name of target feature column
+        - label (str): name of target feature column
         - task (PredictionTask): classification, regression
         - adjusted_metric (bool): if True, return metric as percentage of max achievable performance
     """
 
     # 0. Infer the prediction task
-    task = get_prediction_task(df=df, label=target)
+    task = get_prediction_task(df=df, label=label)
 
     # 1. Define the baseline performance metric
     metric = roc_auc_score if task == 'classification' else mean_squared_error
 
     # 2. Get the baseline predictions
-    y_pred, _, y_test = baseline_predictions(df=df, target=target, task=task)
+    y_pred, _, y_test = baseline_predictions(df=df, label=label, task=task)
 
     # 3. Get the performance
     if adjusted_metric:
@@ -119,17 +120,17 @@ def adjusted_performance(y_true, y_pred, task: PredictionTask, metric: callable)
     return (real_perf - base_perf) / (best_perf - base_perf)
 
 @ignore_warnings(category=DataConversionWarning)
-def performance_per_feature_values(df: pd.DataFrame, feature: str, target: str, task='classification'):
+def performance_per_feature_values(df: pd.DataFrame, feature: str, label: str, task='classification'):
     """Performance achieved per each value of a groupby feature."""
 
     # 0. Infer the prediction task
-    task = get_prediction_task(df=df, label=target)
+    task = get_prediction_task(df=df, label=label)
 
     # 1. Define the baseline performance metric
     metric = roc_auc_score if task == 'classification' else mean_squared_error
 
     # 2. Get the baseline predictions
-    y_pred, X_test, y_test = baseline_predictions(df=df, target=target, task=task)
+    y_pred, X_test, y_test = baseline_predictions(df=df, label=label, task=task)
 
     # 3. Get the performances per feature value
     uniques = set(X_test[feature])
@@ -144,17 +145,17 @@ def performance_per_feature_values(df: pd.DataFrame, feature: str, target: str,
 
     return results
 
-def performance_per_missing_value(df: pd.DataFrame, feature: str, target: str, task='classification'):
+def performance_per_missing_value(df: pd.DataFrame, feature: str, label: str, task='classification'):
     """Performance difference between valued and missing values in feature."""
 
     # 0. Infer the prediction task
-    task = get_prediction_task(df=df, label=target)
+    task = get_prediction_task(df=df, label=label)
 
     # 1. Define the baseline performance metric
     metric = roc_auc_score if task == 'classification' else mean_squared_error
 
     # 2. Get the baseline predictions
-    y_pred, X_test, y_test = baseline_predictions(df=df, target=target, task=task)
+    y_pred, X_test, y_test = baseline_predictions(df=df, label=label, task=task)
 
     # 3. Get the performance per valued vs missing feature
     missing_mask = X_test[feature].isna()

From e84482f41fbf053cb2001b5d3a8d66a8bd283174 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 19:20:01 +0100
Subject: [PATCH 03/10] instantiating loggers in engine

---
 src/ydata_quality/core/data_quality.py | 17 ++++++++++-------
 src/ydata_quality/core/engine.py       | 26 ++++++++++++++++----------
 2 files changed, 26 insertions(+), 17 deletions(-)

diff --git a/src/ydata_quality/core/data_quality.py b/src/ydata_quality/core/data_quality.py
index 463194e4..609ef5d7 100644
--- a/src/ydata_quality/core/data_quality.py
+++ b/src/ydata_quality/core/data_quality.py
@@ -15,6 +15,7 @@
 from ydata_quality.data_expectations import DataExpectationsReporter
 from ydata_quality.bias_fairness import BiasFairness
 from ydata_quality.data_relations import DataRelationsDetector
+from ydata_quality.utils.logger import *
 
 class DataQuality:
     "DataQuality contains the multiple data quality engines."
@@ -55,7 +56,7 @@ def __init__(self,
             label (str, optional): [MISSINGS, LABELLING, DRIFT ANALYSIS] target feature to be predicted.
                                     If not specified, LABELLING is skipped.
             random_state (int, optional): Integer seed for random reproducibility. Default is None.
-                Set to None for fully random behaviour, no reproducibility.
+                Set to None for fully random behavior, no reproducibility.
             entities: [DUPLICATES] entities relevant for duplicate analysis.
             is_close: [DUPLICATES] Pass True to use numpy.isclose instead of pandas.equals in column comparison.
             ed_extensions: [ERRONEOUS DATA] A list of user provided erroneous data values to append to defaults.
@@ -75,10 +76,12 @@ def __init__(self,
         #TODO: Refactor legacy engines (property based) and logic in this class to new base (lean objects)
         self.df = df
         self._warnings = list()
+        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
         self._random_state = random_state
+
         self._engines_legacy = { # Default list of engines
             'duplicates': DuplicateChecker(df=df, entities=entities, is_close=is_close),
-            'missings': MissingsProfiler(df=df, target=label, random_state=self.random_state),
+            'missings': MissingsProfiler(df=df, label=label, random_state=self.random_state),
             'erroneous-data': ErroneousDataIdentifier(df=df, ed_extensions=ed_extensions),
             'drift': DriftAnalyser(ref=df, sample=sample, label=label, model=model, random_state=self.random_state)
         }
@@ -96,16 +99,16 @@ def __init__(self,
         if label is not None:
             self._engines_legacy['labelling'] = LabelInspector(df=df, label=label, random_state=self.random_state)
         else:
-            print('Label is not defined. Skipping LABELLING engine.')
+            self._logger.warning('Label is not defined. Skipping LABELLING engine.')
         if len(sensitive_features)>0:
             self._engines_legacy['bias&fairness'] = BiasFairness(df=df, sensitive_features=sensitive_features,
                                                                  label=label, random_state=self.random_state)
         else:
-            print('Sensitive features not defined. Skipping BIAS & FAIRNESS engine.')
+            self._logger.warning('Sensitive features not defined. Skipping BIAS & FAIRNESS engine.')
         if results_json_path is not None:
             self._engines_new['expectations'] = DataExpectationsReporter()
         else:
-            print('The path to a Great Expectations results json is not defined. Skipping EXPECTATIONS engine.')
+            self._logger.warning('The path to a Great Expectations results json is not defined. Skipping EXPECTATIONS engine.')
 
 
     def __clean_warnings(self):
@@ -140,7 +143,7 @@ def random_state(self, new_state):
         if new_state==None or (isinstance(new_state, int) and new_state>=0):
             self._random_state = new_state
         else:
-            print('An invalid random state was passed. Acceptable values are integers >= 0 or None. Setting to None (no reproducibility).')
+            self._logger.warning('An invalid random state was passed. Acceptable values are integers >= 0 or None. Setting to None (no reproducibility).')
             self._random_state = None
 
     def __store_warnings(self):
@@ -158,7 +161,7 @@ def report(self):
         self.__store_warnings() # fetch all warnings from the engines
         self.__clean_warnings()
         if not self._warnings:
-            print('No warnings found.')
+            self._logger.info('No warnings found.')
         else:
             prio_counts = Counter([warn.priority.value for warn in self._warnings])
             print('Warnings count by priority:')
diff --git a/src/ydata_quality/core/engine.py b/src/ydata_quality/core/engine.py
index f4da37b4..539c82a1 100644
--- a/src/ydata_quality/core/engine.py
+++ b/src/ydata_quality/core/engine.py
@@ -11,6 +11,7 @@
 from ydata_quality.core.warnings import Priority, QualityWarning
 from ydata_quality.utils.auxiliary import infer_df_type, infer_dtypes
 from ydata_quality.utils.enum import DataFrameType
+from ydata_quality.utils.logger import *
 
 
 class QualityEngine(ABC):
@@ -20,6 +21,7 @@ def __init__(self, df: pd.DataFrame, random_state: Optional[int] = None, label:
         self._df = df
         self._df_type = None
         self._warnings = list()
+        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
         self._tests = []
         self._label = label
         self._dtypes = dtypes
@@ -37,9 +39,8 @@ def label(self):
 
     @label.setter
     def label(self, label: str):
-        if not isinstance(label, str):
-            raise ValueError("Property 'label' should be a string.")
-        assert label in self.df.columns, "Given label should exist as a DataFrame column."
+        assert isinstance(label, str), "Property 'label' should be a string."
+        assert label in self.df.columns, "Provided label %s does not exist as a DataFrame column." % label
         self._label = label
 
     @property
@@ -52,11 +53,16 @@ def dtypes(self):
     @dtypes.setter
     def dtypes(self, dtypes: dict):
         if not isinstance(dtypes, dict):
-            raise ValueError("Property 'dtypes' should be a dictionary.")
-        assert all(col in self.df.columns for col in dtypes), "All dtypes keys must be columns in the dataset."
+            self._logger.warning("Property 'dtypes' should be a dictionary. Defaulting to all column dtypes inference.")
+            dtypes = {}
+        cols_not_in_df = [col for col in dtypes if col not in self.df.columns]
+        if len(cols_not_in_df) > 0:
+            self._logger.warning("Passed dtypes keys %s are not columns of the provided dataset.", cols_not_in_df)
         supported_dtypes = ['numerical', 'categorical']
-        assert all(dtype in supported_dtypes for dtype in dtypes.values()), "Assigned dtypes must be in the supported \
-broad dtype list: {}.".format(supported_dtypes)
+        wrong_dtypes = [col for col, dtype in dtypes.items() if dtype not in supported_dtypes]
+        if len(wrong_dtypes>0):
+            self._logger.warning("Columns %s of dtypes where not defined with a supported dtype and will be inferred.", wrong_dtypes)
+        dtypes = {key:val for key, val in dtypes.items() if key not in cols_not_in_df+wrong_dtypes}
         df_col_set = set(self.df.columns)
         dtypes_col_set = set(dtypes.keys())
         missing_cols = df_col_set.difference(dtypes_col_set)
@@ -85,7 +91,7 @@ def random_state(self, new_state):
             self._random_state = new_state
             random.seed(self.random_state)
         except:
-            print('An invalid random state was passed. Acceptable values are integers >= 0 or None. Setting to None.')
+            self._logger.warning('An invalid random state was passed. Acceptable values are integers >= 0 or None. Setting to None.')
             self._random_state = None
 
     def __clean_warnings(self):
@@ -116,7 +122,7 @@ def report(self):
         "Prints a report containing all the warnings detected during the data quality analysis."
         self.__clean_warnings()
         if not self._warnings:
-            print('No warnings found.')
+            self._logger.info('No warnings found.')
         else:
             prio_counts = Counter([warn.priority.value for warn in self._warnings])
             print('Warnings count by priority:')
@@ -133,6 +139,6 @@ def evaluate(self):
             try: # if anything fails
                 results[test] = getattr(self, test)()
             except Exception as exc: # print a Warning and log the message
-                print(f'WARNING: Skipping test {test} due to failure during computation.')
+                self._logger.warning('Skipping test due to failure during computation. See results folder of this test for further details.')
                 results[test] = "[ERROR] Test failed to compute. Original exception: "+f"{exc}"
         return results

From ab018d4c9848563a88404b892919522ed1180da6 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 19:20:32 +0100
Subject: [PATCH 04/10] change prints to logs

---
 src/ydata_quality/bias_fairness/engine.py     |  3 +-
 src/ydata_quality/data_expectations/engine.py |  4 +--
 src/ydata_quality/data_relations/engine.py    | 16 +++++----
 src/ydata_quality/drift/engine.py             |  8 ++---
 src/ydata_quality/duplicates/engine.py        | 10 ++++--
 src/ydata_quality/erroneous_data/engine.py    |  8 ++---
 src/ydata_quality/labelling/engine.py         | 12 +++----
 src/ydata_quality/missings/engine.py          | 34 +++++++------------
 8 files changed, 45 insertions(+), 50 deletions(-)

diff --git a/src/ydata_quality/bias_fairness/engine.py b/src/ydata_quality/bias_fairness/engine.py
index c9c2ee38..5c63ff09 100644
--- a/src/ydata_quality/bias_fairness/engine.py
+++ b/src/ydata_quality/bias_fairness/engine.py
@@ -93,8 +93,7 @@ def performance_discrimination(self):
         """
         # TODO: support error rate parity metrics (e.g. false positive rate, positive rate)
         if self.label is None:
-            print('[BIAS&FAIRNESS] Argument "label" must be defined to calculate performance discrimination metric. Skipping test.')
-            pass
+            self._logger.warning('Argument "label" must be defined to calculate performance discrimination metric. Skipping test.')
 
         res = {}
         for feat in self.sensitive_features:
diff --git a/src/ydata_quality/data_expectations/engine.py b/src/ydata_quality/data_expectations/engine.py
index 07e20b15..82b0915a 100644
--- a/src/ydata_quality/data_expectations/engine.py
+++ b/src/ydata_quality/data_expectations/engine.py
@@ -183,10 +183,10 @@ def evaluate(self, results_json_path: str, df: pd.DataFrame = None, error_tol: i
                 results['Coverage Fraction'] = self._coverage_fraction(
                     results_json_path, df, minimum_coverage=minimum_coverage)
             except AssertionError as exc: # print a Warning and log the message
-                print("['DATA EXPECTATIONS'] Canceled Data Expectations engine execution due to dataset-expectation suite mismatch.")
+                self._logger.critical("Canceled Data Expectations engine execution due to dataset-expectation suite mismatch.")
                 return "[ERROR] Canceled computation. Original exception: "+f"{exc}"
         else:
-            print("A valid DataFrame was not passed, skipping coverage fraction test.")
+            self._logger.error("A valid DataFrame was not passed, skipping coverage fraction test.")
         results['Overall Assessment'] = self._overall_assessment(results_json_path, error_tol, rel_error_tol)
         results['Expectation Level Assessment'] = self._expectation_level_assessment(results_json_path)
         return results
diff --git a/src/ydata_quality/data_relations/engine.py b/src/ydata_quality/data_relations/engine.py
index 196fa75c..ca648f38 100644
--- a/src/ydata_quality/data_relations/engine.py
+++ b/src/ydata_quality/data_relations/engine.py
@@ -29,12 +29,16 @@ def dtypes(self):
     def dtypes(self, df_dtypes: Tuple[pd.DataFrame, dict]):
         df, dtypes = df_dtypes
         if not isinstance(dtypes, dict):
-            raise ValueError("Property 'dtypes' should be a dictionary.")
-        assert all(col in df.columns for col in dtypes), "All dtypes keys \
-            must be columns in the dataset."
+            self._logger.warning("Property 'dtypes' should be a dictionary. Defaulting to all column dtypes inference.")
+            dtypes = {}
+        cols_not_in_df = [col for col in dtypes if col not in df.columns]
+        if len(cols_not_in_df) > 0:
+            self._logger.warning("Passed dtypes keys %s are not columns of the provided dataset.", cols_not_in_df)
         supported_dtypes = ['numerical', 'categorical']
-        assert all(dtype in supported_dtypes for dtype in dtypes.values()), "Assigned dtypes\
-             must be in the supported broad dtype list: {}.".format(supported_dtypes)
+        wrong_dtypes = [col for col, dtype in dtypes.items() if dtype not in supported_dtypes]
+        if len(wrong_dtypes)>0:
+            self._logger.warning("Columns %s of dtypes where not defined with a supported dtype and will be inferred.", wrong_dtypes)
+        dtypes = {key:val for key, val in dtypes.items() if key not in cols_not_in_df+wrong_dtypes}
         df_col_set = set(df.columns)
         dtypes_col_set = set(dtypes.keys())
         missing_cols = df_col_set.difference(dtypes_col_set)
@@ -77,7 +81,7 @@ def evaluate(self, df: pd.DataFrame, dtypes: Optional[dict] = None, label: str=N
             results['Confounders'] = self._confounder_detection(corr_mat, p_corr_mat, corr_th)
             results['Colliders'] = self._collider_detection(corr_mat, p_corr_mat, corr_th)
         else:
-            print('[DATA RELATIONS] The partial correlation matrix is not computable for this dataset. Skipping potential confounder and collider detection tests.')
+            self._logger.warning('The partial correlation matrix is not computable for this dataset. Skipping potential confounder and collider detection tests.')
         if label:
             results['Feature Importance'] = self._feature_importance(corr_mat, p_corr_mat, label, corr_th)
         results['High Collinearity'] = self._high_collinearity_detection(df, self.dtypes, label, vif_th, p_th=p_th)
diff --git a/src/ydata_quality/drift/engine.py b/src/ydata_quality/drift/engine.py
index d209ea4a..1edeb219 100644
--- a/src/ydata_quality/drift/engine.py
+++ b/src/ydata_quality/drift/engine.py
@@ -223,7 +223,7 @@ def ref_label_drift(self, p_thresh: float= 0.05):
         Args:
             p_thresh (float): The p_threshold used for the test."""
         if self.label is None:
-            print("[REFERENCE LABEL DRIFT] No label was provided. Test skipped.")
+            self._logger.warning("No label was provided. Test skipped.")
             return
         labels = self._remaining_data[self.label].copy()
         holdout = self._holdout[self.label]
@@ -280,7 +280,7 @@ def sample_covariate_drift(self, p_thresh: float= 0.05) -> pd.DataFrame:
                     description=f"""There were {n_invalid_tests} invalid tests found. This is likely due to a small test sample size. The data summary should be analyzed before considering the test conclusive."""
             ))
         else:
-            print("[SAMPLE COVARIATE DRIFT] Covariate drift was not detected in the test sample.")
+            self._logger.info("Covariate drift was not detected in the test sample.")
         return test_summary
 
     def sample_label_drift(self, p_thresh: float= 0.05) -> pd.Series:
@@ -312,7 +312,7 @@ def sample_label_drift(self, p_thresh: float= 0.05) -> pd.Series:
                     description="The test was invalid. This is likely due to a small test sample size."
             ))
         else:
-            print("[SAMPLE LABEL DRIFT] Label drift was not detected in the test sample.")
+            self._logger.info("Label drift was not detected in the test sample.")
         return test_summary
 
     def sample_concept_drift(self, p_thresh: float= 0.05) -> pd.Series:
@@ -349,5 +349,5 @@ def sample_concept_drift(self, p_thresh: float= 0.05) -> pd.Series:
                     description="The test was invalid. This is likely due to a small test sample size."
             ))
         else:
-            print("[CONCEPT DRIFT] Concept drift was not detected between the reference and the test samples.")
+            self._logger.info("Concept drift was not detected between the reference and the test samples.")
         return test_summary
diff --git a/src/ydata_quality/duplicates/engine.py b/src/ydata_quality/duplicates/engine.py
index e84ed002..ffb8616c 100644
--- a/src/ydata_quality/duplicates/engine.py
+++ b/src/ydata_quality/duplicates/engine.py
@@ -14,6 +14,10 @@ class DuplicateChecker(QualityEngine):
     "Engine for running analyis on duplicate records."
 
     def __init__(self, df: pd.DataFrame, entities: List[Union[str, List[str]]] = [], is_close: bool=False):
+        """
+            df (pd.DataFrame): reference DataFrame used to run the DataQuality analysis.
+            entities (List[Union[str, List[str]]]): entities relevant for duplicate analysis. Passing lists allows composed entities of multiple columns.
+            is_close (bool): Pass True to use numpy.isclose instead of pandas.equals in column comparison."""
         super().__init__(df=df)
         self._entities = entities
         self._tests = ["exact_duplicates", "entity_duplicates", "duplicate_columns"]
@@ -58,7 +62,7 @@ def exact_duplicates(self):
                     description=f"Found {len(dups)} instances with exact duplicate feature values."
             ))
         else:
-            print("[EXACT DUPLICATES] No exact duplicates were found.")
+            self._logger.info("No exact duplicates were found.")
             dups = None
         return dups
 
@@ -92,7 +96,7 @@ def entity_duplicates(self, entity: Optional[Union[str, List[str]]] = None):
                     ent_dups.setdefault(entity_key, {})[val] = dups[(dups[entity].values==val).all(axis=1)]
         else: # if entity is not specified
             if len(self.entities) == 0:
-                print("[ENTITY DUPLICATES] There are no entities defined to run the analysis. Skipping the test.")
+                self._logger.info("There are no entities defined to run the analysis. Skipping the test.")
                 return None
             else:
                 for col in self.entities:
@@ -111,6 +115,6 @@ def duplicate_columns(self):
                 )
             )
         else:
-            print("[DUPLICATE COLUMNS] No duplicate columns were found.")
+            self._logger.info("No duplicate columns were found.")
             dups = None
         return dups
diff --git a/src/ydata_quality/erroneous_data/engine.py b/src/ydata_quality/erroneous_data/engine.py
index c6d1f599..25b6b7ff 100644
--- a/src/ydata_quality/erroneous_data/engine.py
+++ b/src/ydata_quality/erroneous_data/engine.py
@@ -83,7 +83,7 @@ def flatlines(self, th: int=5, skip: list=[]):
             skip: List of columns that will not be target of search for flatlines.
                 Pass '__index' inside skip list to skip looking for flatlines at the index."""
         if self.df_type == DataFrameType.TABULAR:
-            print('[FLATLINES] The provided DataFrame is not a valid Timeseries type, skipping this test.')
+            self._logger.info('The provided DataFrame is not a valid Timeseries type, skipping this test.')
             return None
         flatlines = {}
         for column in self.df.columns:  # Compile flatline index
@@ -101,7 +101,7 @@ def flatlines(self, th: int=5, skip: list=[]):
             ))
             return flatlines
         else:
-            print("[FLATLINES] No flatline events with a minimum length of {} were found.".format(th))
+            self._logger.info("No flatline events with a minimum length of %f were found.", th)
 
     def predefined_erroneous_data(self, skip: list=[], short: bool = True):
         """Runs a check against a list of predefined erroneous data values.
@@ -127,9 +127,7 @@ def predefined_erroneous_data(self, skip: list=[], short: bool = True):
             eds.drop(no_ed_cols, axis=1, inplace=True)
             eds.drop(no_ed_rows, inplace=True)
         if eds.empty:
-            print("[PREDEFINED ERRONEOUS DATA] No predefined ED values from  the set {} were found in the dataset.".format(
-                self.err_data
-            ))
+            self._logger.info("No predefined ED values from  the set %s were found in the dataset.", self.err_data)
         else:
             total_eds = eds.sum().sum()
             self.store_warning(
diff --git a/src/ydata_quality/labelling/engine.py b/src/ydata_quality/labelling/engine.py
index ab671118..98585ab4 100644
--- a/src/ydata_quality/labelling/engine.py
+++ b/src/ydata_quality/labelling/engine.py
@@ -61,7 +61,7 @@ def missing_labels(self):
                     description=f"Found {len(missing_labels)} instances with missing labels."
             ))
         else:
-            print("[MISSING LABELS] No missing labels were found.")
+            self._logger.info("No missing labels were found.")
             missing_labels = None
         return missing_labels
 
@@ -112,7 +112,7 @@ def few_labels(self, count_th: Union[int, float] = 1):
                     "Found {} labels with {} or less records.".format(len(few_labels), count_th)
             ))
         else:
-            print("[FEW LABELS] No labels with {} or less records were found.".format(count_th))
+            self._logger.info("No labels with %d or less records were found.", count_th)
             few_labels = None
         return few_labels
 
@@ -149,7 +149,7 @@ def unbalanced_classes(self, slack: float = 0.3):
     set(data['Over-represented'].keys()), fair_share+adj_slack)
     ))
         else:
-            print("[UNBALANCED CLASSES] No unbalanced classes were found.")
+            self._logger.info("No unbalanced classes were found.")
             return None
         return label_excess.index
 
@@ -299,9 +299,9 @@ def test_normality(self, p_th=5e-3):
         test_result, transform, pstat = normality_test(vals, p_th=p_th)
         if test_result:
             if transform is None:
-                print("[TEST NORMALITY] The label values appears to be normally distributed.")
+                self._logger.info("The label values appears to be normally distributed.")
             else:
-                print("[TEST NORMALITY] The {} transform appears to be able to normalize the label values.".format(transform))
+                self._logger.info("The %s transform appears to be able to normalize the label values.", transform)
                 self.store_warning(
                     QualityWarning(
                         test='Test normality', category='Labels', priority=2, data=vals,
@@ -310,7 +310,7 @@ def test_normality(self, p_th=5e-3):
     transform, pstat)
                 ))
         else:
-            print("[TEST NORMALITY] It was not possible to normalize the label values. See the warning message for additional context.")
+            self._logger.warning("It was not possible to normalize the label values. See the data quality warning message for additional context.")
             self.store_warning(
                 QualityWarning(
                     test='Test normality', category='Labels', priority=1, data=vals,
diff --git a/src/ydata_quality/missings/engine.py b/src/ydata_quality/missings/engine.py
index 2cb69abc..992e0af0 100644
--- a/src/ydata_quality/missings/engine.py
+++ b/src/ydata_quality/missings/engine.py
@@ -15,27 +15,18 @@
 class MissingsProfiler(QualityEngine):
     "Main class to run missing value analysis."
 
-    def __init__(self, df: pd.DataFrame, target: Optional[str] = None, random_state: Optional[int]=None):
+    def __init__(self, df: pd.DataFrame, label: Optional[str] = None, random_state: Optional[int]=None):
         """
         Args:
             df (pd.DataFrame): reference DataFrame used to run the missing value analysis.
-            target (str, optional): target
+            label (str, optional): target feature to be predicted.
+            random_state (int, optional): Integer seed for random reproducibility. Default is None.
+                Set to None for fully random behavior, no reproducibility.
         """
-        #TODO: Rename 'target' argument to 'label' standard of QualityEngine
         super().__init__(df=df, random_state=random_state)
-        self._target = target
+        self._label = label
         self._tests = ["nulls_higher_than", "high_missing_correlations", "predict_missings"]
 
-    @property
-    def target(self):
-        return self._target
-
-    @target.setter
-    def target(self, target: str):
-        if target not in self.df.columns:
-            raise Exception(f'Provided target ({target}) must belong to the dataframe columns ({list(self.df.columns)}).')
-        self._target = target
-
     def _get_null_cols(self, col: Optional[str] = None) -> List[str]:
         "Returns list of given column or all columns with null values in DataFrame if None."
         return list(self.df.columns[self.null_count(minimal=False)>0]) if col is None \
@@ -43,9 +34,9 @@ def _get_null_cols(self, col: Optional[str] = None) -> List[str]:
             else [col]
 
     def __get_prediction_type(self):
-        "Decide whether to use classification or regression setting, based on target."
+        "Decide whether to use classification or regression setting, based on label."
         # TODO: Improve prediction type guesstimate based on alternative heuristics (e.g. dtypes, value_counts)
-        if len(set(self.df[self.target])) == 2: # binary classification
+        if len(set(self.df[self.label])) == 2: # binary classification
             return 'classification'
         else:
             return 'regression'
@@ -128,21 +119,20 @@ def performance_drop(self, col: Union[List[str], str, None] = None, normalize=Tr
         # Parse the columns for which to calculate the drop in performance on missings
         cols = self._get_null_cols(col)
 
-        # Guarantee that target is defined. Otherwise skip
-        if self.target is None:
-            print('Argument "target" must be defined to calculate performance_drop metric. Skipping test.')
-            pass
+        # Guarantee that label is defined. Otherwise skip
+        if self.label is None:
+            self._logger.warning('Argument "label" must be defined to calculate performance_drop metric. Skipping test.')
 
         # Guesstimate the prediction type
         prediction_type = self.__get_prediction_type()
         results = pd.DataFrame({
-            c: performance_per_missing_value(df=self.df, feature=c, target=self.target, task=prediction_type)
+            c: performance_per_missing_value(df=self.df, feature=c, label=self.label, task=prediction_type)
             for c in cols
         })
 
         # Normalize the results with a baseline performance.
         if normalize:
-            baseline = baseline_performance(df=self.df, target=self.target, task=prediction_type)
+            baseline = baseline_performance(df=self.df, label=self.label, task=prediction_type)
             results = results / baseline
 
         return results

From a42b95ba25b7b32a7c20a9fea2ef832476d2fc3d Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 20:05:50 +0100
Subject: [PATCH 05/10] Fix runtime issues in aux methods

---
 src/ydata_quality/core/engine.py              |  1 -
 src/ydata_quality/data_expectations/engine.py |  7 +-
 src/ydata_quality/data_relations/engine.py    |  9 +-
 src/ydata_quality/utils/auxiliary.py          | 14 +--
 tutorials/data_quality.ipynb                  | 61 +++++--------
 tutorials/main.ipynb                          | 88 ++++++++++++++-----
 6 files changed, 102 insertions(+), 78 deletions(-)

diff --git a/src/ydata_quality/core/engine.py b/src/ydata_quality/core/engine.py
index 539c82a1..b40060d9 100644
--- a/src/ydata_quality/core/engine.py
+++ b/src/ydata_quality/core/engine.py
@@ -10,7 +10,6 @@
 
 from ydata_quality.core.warnings import Priority, QualityWarning
 from ydata_quality.utils.auxiliary import infer_df_type, infer_dtypes
-from ydata_quality.utils.enum import DataFrameType
 from ydata_quality.utils.logger import *
 
 
diff --git a/src/ydata_quality/data_expectations/engine.py b/src/ydata_quality/data_expectations/engine.py
index 82b0915a..72a55431 100644
--- a/src/ydata_quality/data_expectations/engine.py
+++ b/src/ydata_quality/data_expectations/engine.py
@@ -8,6 +8,7 @@
 
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.auxiliary import test_load_json_path
+from ydata_quality.utils.logger import *
 
 
 class DataExpectationsReporter(QualityEngine):
@@ -15,8 +16,9 @@ class DataExpectationsReporter(QualityEngine):
     Supports standard Great Expectations json reports from expectation suite validation runs.
     """
 
-    def __init__(self):
-        return  # Override the base class init method
+    def __init__(self):  # Overrides base class init
+        self._warnings = [] # reset the warnings to avoid duplicates
+        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
 
     @property
     def tests(self):
@@ -175,7 +177,6 @@ def evaluate(self, results_json_path: str, df: pd.DataFrame = None, error_tol: i
             rel_error_tol (float): Defines the maximum fraction of failed expectations, overrides error_tol.
             minimum_coverage (float): Minimum expected fraction of DataFrame columns covered by the expectation suite.
         """
-        self._warnings = list() # reset the warnings to avoid duplicates
         df = df if isinstance(df, pd.DataFrame) else None
         results = {}
         if df is not None:
diff --git a/src/ydata_quality/data_relations/engine.py b/src/ydata_quality/data_relations/engine.py
index ca648f38..823748ac 100644
--- a/src/ydata_quality/data_relations/engine.py
+++ b/src/ydata_quality/data_relations/engine.py
@@ -9,13 +9,15 @@
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.correlations import correlation_matrix, partial_correlation_matrix, correlation_plotter, vif_collinearity, chi2_collinearity
 from ydata_quality.utils.auxiliary import infer_dtypes, standard_normalize
+from ydata_quality.utils.logger import *
 
 class DataRelationsDetector(QualityEngine):
     """Main class to run data relations analysis.
     """
 
-    def __init__(self):
-        return  # Override the base class init method
+    def __init__(self):  # Overrides base class init
+        self._warnings = [] # reset the warnings to avoid duplicates
+        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
 
     @property
     def tests(self):
@@ -64,9 +66,6 @@ def evaluate(self, df: pd.DataFrame, dtypes: Optional[dict] = None, label: str=N
             plot (bool): Pass True to produce all available graphical outputs, False to suppress all graphical output.
         """
         assert label in df.columns or not label, "The provided label name does not exist as a column in the dataset"
-        self._warnings = [] # reset the warnings to avoid duplicates
-        if not dtypes:
-            dtypes = {}
         self.dtypes = (df, dtypes)  # Consider refactoring QualityEngine dtypes (df as argument of setter)
         df = standard_normalize(df, dtypes)
         results = {}
diff --git a/src/ydata_quality/utils/auxiliary.py b/src/ydata_quality/utils/auxiliary.py
index d00c9e78..a277754e 100644
--- a/src/ydata_quality/utils/auxiliary.py
+++ b/src/ydata_quality/utils/auxiliary.py
@@ -50,9 +50,10 @@ def min_max_normalize(df: pd.DataFrame, dtypes: dict) -> pd.DataFrame:
     Args:
         df (pd.DataFrame): DataFrame to be normalized
         dtypes (dict): Map of column names to variable types"""
-    numeric_features = [col for col in df.columns if dtypes[col]=='numerical']
-    scaled_data = MinMaxScaler().fit_transform(df[numeric_features].values)
-    df[numeric_features] = scaled_data
+    numeric_features = [col for col in df.columns if dtypes.get(col)=='numerical']
+    if numeric_features:
+        scaled_data = MinMaxScaler().fit_transform(df[numeric_features].values)
+        df[numeric_features] = scaled_data
     return df
 
 def standard_normalize(df: pd.DataFrame, dtypes: dict) -> pd.DataFrame:
@@ -61,9 +62,10 @@ def standard_normalize(df: pd.DataFrame, dtypes: dict) -> pd.DataFrame:
     Args:
         df (pd.DataFrame): DataFrame to be normalized
         dtypes (dict): Map of column names to variable types"""
-    numeric_features = [col for col in df.columns if dtypes[col]=='numerical']
-    scaled_data = StandardScaler().fit_transform(df[numeric_features].values)
-    df[numeric_features] = scaled_data
+    numeric_features = [col for col in df.columns if dtypes.get(col)=='numerical']
+    if numeric_features:
+        scaled_data = StandardScaler().fit_transform(df[numeric_features].values)
+        df[numeric_features] = scaled_data
     return df
 
 def find_duplicate_columns(df: pd.DataFrame, is_close=False) -> dict:
diff --git a/tutorials/data_quality.ipynb b/tutorials/data_quality.ipynb
index 75fbc03f..471b7d82 100644
--- a/tutorials/data_quality.ipynb
+++ b/tutorials/data_quality.ipynb
@@ -24,7 +24,6 @@
    "execution_count": 1,
    "source": [
     "import pandas as pd\n",
-    "import numpy as np\n",
     "from ydata_quality import DataQuality"
    ],
    "outputs": [],
@@ -97,10 +96,8 @@
      "output_type": "stream",
      "name": "stdout",
      "text": [
-      "[ENTITY DUPLICATES] There are no entities defined to run the analysis. Skipping the test.\n",
-      "WARNING: Skipping test predict_missings due to failure during computation.\n",
-      "[PREDEFINED ERRONEOUS DATA] No predefined ED values from  the set {'', 'unknown', 'unk', 'a_custom_edv', '?', '(blank)', 'na', '!', 'n/a', 999999999} were found in the dataset.\n",
-      "WARNING: Skipping test ref_covariate_drift due to failure during computation.\n"
+      "WARNING | Skipping test due to failure during computation. See results folder of this test for further details.\n",
+      "WARNING | Skipping test due to failure during computation. See results folder of this test for further details.\n"
      ]
     },
     {
@@ -117,19 +114,9 @@
      "output_type": "stream",
      "name": "stdout",
      "text": [
-      "[MISSING LABELS] No missing labels were found.\n",
-      "[TEST NORMALITY] It was not possible to normalize the label values. See the warning message for additional context.\n",
-      "WARNING: Skipping test performance_discrimination due to failure during computation.\n"
-     ]
-    },
-    {
-     "output_type": "stream",
-     "name": "stderr",
-     "text": [
-      "/home/fsantos/GitRepos/ydata-quality/src/ydata_quality/utils/correlations.py:132: RuntimeWarning: invalid value encountered in sqrt\n",
-      "  scaled_diag = np.diag(np.sqrt(1 / diag))\n",
-      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/statsmodels/stats/outliers_influence.py:193: RuntimeWarning: divide by zero encountered in double_scalars\n",
-      "  vif = 1. / (1. - r_squared_i)\n"
+      "WARNING | It was not possible to normalize the label values. See the data quality warning message for additional context.\n",
+      "WARNING | Skipping test due to failure during computation. See results folder of this test for further details.\n",
+      "WARNING | Skipping test due to failure during computation. See results folder of this test for further details.\n"
      ]
     },
     {
@@ -142,21 +129,12 @@
      },
      "metadata": {}
     },
-    {
-     "output_type": "display_data",
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 1400x1400 with 2 Axes>"
-      ]
-     },
-     "metadata": {}
-    },
     {
      "output_type": "stream",
      "name": "stdout",
      "text": [
-      "['DATA EXPECTATIONS'] Canceled Data Expectations engine execution due to dataset-expectation suite mismatch.\n"
+      "WARNING | The partial correlation matrix is not computable for this dataset. Skipping potential confounder and collider detection tests.\n",
+      "CRITICAL | Canceled Data Expectations engine execution due to dataset-expectation suite mismatch.\n"
      ]
     }
    ],
@@ -184,19 +162,24 @@
      "text": [
       "Warnings count by priority:\n",
       "\tPriority 1: 2 warning(s)\n",
-      "\tPriority 2: 8 warning(s)\n",
-      "\tTOTAL: 10 warning(s)\n",
+      "\tPriority 2: 5 warning(s)\n",
+      "\tTOTAL: 7 warning(s)\n",
       "List of warnings sorted by priority:\n",
       "\t[TEST NORMALITY] The label distribution failed to pass a normality test as-is and following a battery of transforms. It is possible that the data originates from an exotic distribution, there is heavy outlier presence or it is multimodal. Addressing this issue might prove critical for regressor performance. (Priority 1: heavy impact expected)\n",
       "\t[DUPLICATE COLUMNS] Found 1 columns with exactly the same feature values as other columns. (Priority 1: heavy impact expected)\n",
-      "\t[COLLIDER CORRELATIONS] Found 99 independently uncorrelated variable pairs that showed correlation after controling for the remaining variables. This is an indicator of potential colliding bias with other covariates. (Priority 2: usage allowed, limited human intelligibility)\n",
       "\t[OUTLIER DETECTION] Found 2 potential outliers across the full dataset. A distance bigger than 3.0 standard deviations of intra-cluster distances to the respective centroids was used to define the potential outliers. (Priority 2: usage allowed, limited human intelligibility)\n",
       "\t[HIGH COLLINEARITY - CATEGORICAL] Found 3 categorical variables with significant collinearity (p-value < 0.05). The variables listed in results are highly collinear with other variables in the dataset and sorted descending according to propensity. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove variables following the provided order. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[PROXY IDENTIFICATION] Found 5 feature pairs of correlation to sensitive attributes with values higher than defined threshold (0.5). (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[CONFOUNDED CORRELATIONS] Found 21 independently correlated variable pairs that disappeared after controling for the remaining variables. This is an indicator of potential confounder effects in the dataset. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[HIGH COLLINEARITY - NUMERICAL] Found 4 numerical variables with high Variance Inflation Factor (VIF>5.0). The variables listed in results are highly collinear with other variables in the dataset. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove the highest VIF variables. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[FLATLINES] Found 8 flatline events with a minimun length of 5 among the columns {'MainCity', 'Region'}. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[EXACT DUPLICATES] Found 20 instances with exact duplicate feature values. (Priority 2: usage allowed, limited human intelligibility)\n"
+      "\t[EXACT DUPLICATES] Found 20 instances with exact duplicate feature values. (Priority 2: usage allowed, limited human intelligibility)\n",
+      "\t[HIGH COLLINEARITY - NUMERICAL] Found 18 numerical variables with high Variance Inflation Factor (VIF>5.0). The variables listed in results are highly collinear with other variables in the dataset. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove the highest VIF variables. (Priority 2: usage allowed, limited human intelligibility)\n",
+      "\t[PROXY IDENTIFICATION] Found 5 feature pairs of correlation to sensitive attributes with values higher than defined threshold (0.5). (Priority 2: usage allowed, limited human intelligibility)\n"
+     ]
+    },
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
      ]
     }
    ],
@@ -231,8 +214,8 @@
      "output_type": "execute_result",
      "data": {
       "text/plain": [
-       "('Outlier Detection',\n",
-       " 'Found 2 potential outliers across the full dataset. A distance bigger than 3.0 standard deviations of intra-cluster distances to the respective centroids was used to define the potential outliers.',\n",
+       "('High Collinearity - Categorical',\n",
+       " 'Found 3 categorical variables with significant collinearity (p-value < 0.05). The variables listed in results are highly collinear with other variables in the dataset and sorted descending according to propensity. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove variables following the provided order.',\n",
        " <Priority.P2: 2>)"
       ]
      },
diff --git a/tutorials/main.ipynb b/tutorials/main.ipynb
index f36f970a..cb545f70 100644
--- a/tutorials/main.ipynb
+++ b/tutorials/main.ipynb
@@ -53,13 +53,22 @@
      "text": [
       "Warnings count by priority:\n",
       "\tPriority 1: 1 warning(s)\n",
-      "\tPriority 2: 3 warning(s)\n",
-      "\tTOTAL: 4 warning(s)\n",
+      "\tPriority 2: 4 warning(s)\n",
+      "\tTOTAL: 5 warning(s)\n",
       "List of warnings sorted by priority:\n",
       "\t[DUPLICATE COLUMNS] Found 1 columns with exactly the same feature values as other columns. (Priority 1: heavy impact expected)\n",
+      "\t[PREDEFINED ERRONEOUS DATA] Found 1960 ED values in the dataset. (Priority 2: usage allowed, limited human intelligibility)\n",
+      "\t[HIGH COLLINEARITY - CATEGORICAL] Found 10 categorical variables with significant collinearity (p-value < 0.05). The variables listed in results are highly collinear with other variables in the dataset and sorted descending according to propensity. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove variables following the provided order. (Priority 2: usage allowed, limited human intelligibility)\n",
       "\t[EXACT DUPLICATES] Found 3 instances with exact duplicate feature values. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[FLATLINES] Found 4627 flatline events with a minimun length of 5 among the columns {'marital-status', 'workclass', 'income', 'native-country', 'capital-gain', 'capital-loss', 'education', 'occupation', 'workclass2', 'sex', 'education-num', 'hours-per-week', 'relationship', 'race'}. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[PREDEFINED ERRONEOUS DATA] Found 1960 ED values in the dataset. (Priority 2: usage allowed, limited human intelligibility)\n"
+      "\t[HIGH COLLINEARITY - NUMERICAL] Found 3 numerical variables with high Variance Inflation Factor (VIF>5.0). The variables listed in results are highly collinear with other variables in the dataset. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove the highest VIF variables. (Priority 2: usage allowed, limited human intelligibility)\n"
+     ]
+    },
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
      ]
     }
    ],
@@ -95,7 +104,7 @@
      "output_type": "execute_result",
      "data": {
       "text/plain": [
-       "{'workclass': 'workclass2'}"
+       "{'workclass': ['workclass2']}"
       ]
      },
      "metadata": {},
@@ -144,6 +153,14 @@
       "\t[PROXY IDENTIFICATION] Found 1 feature pairs of correlation to sensitive attributes with values higher than defined threshold (0.5). (Priority 2: usage allowed, limited human intelligibility)\n",
       "\t[SENSITIVE ATTRIBUTE REPRESENTATIVITY] Found 2 values of 'race' sensitive attribute with low representativity in the dataset (below 1.00%). (Priority 2: usage allowed, limited human intelligibility)\n"
      ]
+    },
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/GitRepos/ydata-quality/src/ydata_quality/bias_fairness/engine.py:72: DeprecationWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  performances = pd.Series(index=self.sensitive_features)\n"
+     ]
     }
    ],
    "metadata": {}
@@ -155,25 +172,23 @@
     "bf_results"
    ],
    "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    },
     {
      "output_type": "execute_result",
      "data": {
       "text/plain": [
-       "{'performance_discrimination': {'race': Black                 0.639949\n",
-       "  Other                 1.000000\n",
-       "  Asian-Pac-Islander    0.510216\n",
-       "  White                 0.562961\n",
-       "  Amer-Indian-Eskimo    1.000000\n",
-       "  dtype: float64,\n",
-       "  'sex': Female    0.526722\n",
-       "  Male      0.591663\n",
-       "  dtype: float64},\n",
+       "{'performance_discrimination': \"[ERROR] Test failed to compute. Original exception: performance_per_feature_values() got an unexpected keyword argument 'target'\",\n",
        " 'proxy_identification': features\n",
        " relationship_sex    0.650656\n",
        " Name: association, dtype: float64,\n",
-       " 'sensitive_predictability': race    0.121680\n",
-       " sex     0.249346\n",
-       " dtype: float64,\n",
+       " 'sensitive_predictability': \"[ERROR] Test failed to compute. Original exception: baseline_performance() got an unexpected keyword argument 'target'\",\n",
        " 'sensitive_representativity': {'race': White                 0.8537\n",
        "  Black                 0.0978\n",
        "  Asian-Pac-Islander    0.0303\n",
@@ -315,11 +330,20 @@
      "name": "stdout",
      "text": [
       "Warnings count by priority:\n",
-      "\tPriority 2: 2 warning(s)\n",
-      "\tTOTAL: 2 warning(s)\n",
+      "\tPriority 2: 3 warning(s)\n",
+      "\tTOTAL: 3 warning(s)\n",
       "List of warnings sorted by priority:\n",
-      "\t[FLATLINES] Found 4165 flatline events with a minimun length of 5 among the columns {'marital-status', 'workclass', 'income', 'native-country', 'capital-gain', 'capital-loss', 'education', 'occupation', 'sex', 'education-num', 'hours-per-week', 'relationship', 'race'}. (Priority 2: usage allowed, limited human intelligibility)\n",
-      "\t[PREDEFINED ERRONEOUS DATA] Found 1360 ED values in the dataset. (Priority 2: usage allowed, limited human intelligibility)\n"
+      "\t[HIGH COLLINEARITY - CATEGORICAL] Found 9 categorical variables with significant collinearity (p-value < 0.05). The variables listed in results are highly collinear with other variables in the dataset and sorted descending according to propensity. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove variables following the provided order. (Priority 2: usage allowed, limited human intelligibility)\n",
+      "\t[PREDEFINED ERRONEOUS DATA] Found 1360 ED values in the dataset. (Priority 2: usage allowed, limited human intelligibility)\n",
+      "\t[HIGH COLLINEARITY - NUMERICAL] Found 3 numerical variables with high Variance Inflation Factor (VIF>5.0). The variables listed in results are highly collinear with other variables in the dataset. These will make model explainability harder and potentially give way to issues like overfitting. Depending on your end goal you might want to remove the highest VIF variables. (Priority 2: usage allowed, limited human intelligibility)\n"
+     ]
+    },
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
      ]
     }
    ],
@@ -353,6 +377,14 @@
       "List of warnings sorted by priority:\n",
       "\t[SENSITIVE ATTRIBUTE REPRESENTATIVITY] Found 2 values of 'race' sensitive attribute with low representativity in the dataset (below 1.00%). (Priority 2: usage allowed, limited human intelligibility)\n"
      ]
+    },
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/GitRepos/ydata-quality/src/ydata_quality/bias_fairness/engine.py:72: DeprecationWarning: The default dtype for empty Series will be 'object' instead of 'float64' in a future version. Specify a dtype explicitly to silence this warning.\n",
+      "  performances = pd.Series(index=self.sensitive_features)\n"
+     ]
     }
    ],
    "metadata": {}
@@ -365,6 +397,14 @@
     "better_bf.proxy_identification(th=0.45)"
    ],
    "outputs": [
+    {
+     "output_type": "stream",
+     "name": "stderr",
+     "text": [
+      "/home/fsantos/miniconda3/envs/DQ/lib/python3.8/site-packages/ipykernel/ipkernel.py:287: DeprecationWarning: `should_run_async` will not call `transform_cell` automatically in the future. Please pass the result to `transformed_cell` argument and any exception that happen during thetransform in `preprocessing_exc_tuple` in IPython 7.17 and above.\n",
+      "  and should_run_async(code)\n"
+     ]
+    },
     {
      "output_type": "execute_result",
      "data": {
@@ -394,7 +434,7 @@
   "orig_nbformat": 4,
   "language_info": {
    "name": "python",
-   "version": "3.8.10",
+   "version": "3.8.11",
    "mimetype": "text/x-python",
    "codemirror_mode": {
     "name": "ipython",
@@ -406,10 +446,10 @@
   },
   "kernelspec": {
    "name": "python3",
-   "display_name": "Python 3.8.10 64-bit ('.venv': venv)"
+   "display_name": "Python 3.8.11 64-bit ('DQ': conda)"
   },
   "interpreter": {
-   "hash": "cdc2bce73c2a9ac283f602628cabf735dbe06c4ee87a7849fc5f3d1177c8f304"
+   "hash": "e255f3ac955330aecee05fff6b7b15b68f4bd4cf0e9481cf0822c8a2e5228d43"
   }
  },
  "nbformat": 4,

From b5f2e58eadd23cb1780639e138ac70431f6862c5 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Tue, 21 Sep 2021 23:28:15 +0100
Subject: [PATCH 06/10] Add warning levels arg and defaults

---
 src/ydata_quality/core/data_quality.py        | 11 ++++++++---
 src/ydata_quality/core/engine.py              |  9 +++++++--
 src/ydata_quality/data_expectations/engine.py |  9 +++++++--
 src/ydata_quality/data_relations/engine.py    |  9 +++++++--
 src/ydata_quality/utils/logger.py             |  1 -
 5 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/src/ydata_quality/core/data_quality.py b/src/ydata_quality/core/data_quality.py
index 609ef5d7..ef5f7ed0 100644
--- a/src/ydata_quality/core/data_quality.py
+++ b/src/ydata_quality/core/data_quality.py
@@ -2,6 +2,7 @@
 Implementation of main class for Data Quality checks.
 """
 from collections import Counter
+from logging import _nameToLevel
 from typing import Callable, List, Optional, Union
 
 import pandas as pd
@@ -38,8 +39,8 @@ def __init__(self,
                     corr_th: float = 0.8,
                     vif_th: float = 5,
                     p_th: float = 0.05,
-                    plot: bool = True
-                    ):
+                    plot: bool = True,
+                    severity: Optional[str]= 'ERROR'):
         """
         Engines:
         - Duplicates
@@ -72,11 +73,15 @@ def __init__(self,
             vif_th (float): [DATA RELATIONS] Variance Inflation Factor threshold for numerical independence test, typically 5-10 is recommended. Defaults to 5.
             p_th (float): [DATA RELATIONS] Fraction of the right tail of the chi squared CDF defining threshold for categorical independence test. Defaults to 0.05.
             plot (bool): Pass True to produce all available graphical outputs, False to suppress all graphical output.
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
         #TODO: Refactor legacy engines (property based) and logic in this class to new base (lean objects)
         self.df = df
         self._warnings = list()
-        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
+        if severity in _nameToLevel:
+            os.environ["DQ_LOG_LEVEL"] = severity
+        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        self._logger = create_logger(NAME, STREAM, log_level)
         self._random_state = random_state
 
         self._engines_legacy = { # Default list of engines
diff --git a/src/ydata_quality/core/engine.py b/src/ydata_quality/core/engine.py
index b40060d9..f669407e 100644
--- a/src/ydata_quality/core/engine.py
+++ b/src/ydata_quality/core/engine.py
@@ -4,6 +4,8 @@
 from abc import ABC
 from collections import Counter
 from typing import Optional
+import os
+from logging import _nameToLevel
 
 import pandas as pd
 from numpy import random
@@ -16,11 +18,14 @@
 class QualityEngine(ABC):
     "Main class for running and storing data quality analysis."
 
-    def __init__(self, df: pd.DataFrame, random_state: Optional[int] = None, label: str = None, dtypes: dict = None):
+    def __init__(self, df: pd.DataFrame, random_state: Optional[int] = None, label: str = None, dtypes: dict = None, severity: Optional[str]= None):
         self._df = df
         self._df_type = None
         self._warnings = list()
-        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
+        if severity in _nameToLevel:
+            os.environ["DQ_LOG_LEVEL"] = severity
+        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        self._logger = create_logger(NAME, STREAM, log_level)
         self._tests = []
         self._label = label
         self._dtypes = dtypes
diff --git a/src/ydata_quality/data_expectations/engine.py b/src/ydata_quality/data_expectations/engine.py
index 72a55431..82468f5f 100644
--- a/src/ydata_quality/data_expectations/engine.py
+++ b/src/ydata_quality/data_expectations/engine.py
@@ -2,6 +2,7 @@
 Implementation of DataExpectationsReporter engine to run data expectations validation analysis.
 """
 from typing import Optional
+from logging import _nameToLevel
 
 import numpy as np
 import pandas as pd
@@ -16,9 +17,13 @@ class DataExpectationsReporter(QualityEngine):
     Supports standard Great Expectations json reports from expectation suite validation runs.
     """
 
-    def __init__(self):  # Overrides base class init
+    def __init__(self, severity: Optional[str]= None):  # Overrides base class init
+        "severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]"
         self._warnings = [] # reset the warnings to avoid duplicates
-        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
+        if severity in _nameToLevel:
+            os.environ["DQ_LOG_LEVEL"] = severity
+        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        self._logger = create_logger(NAME, STREAM, log_level)
 
     @property
     def tests(self):
diff --git a/src/ydata_quality/data_relations/engine.py b/src/ydata_quality/data_relations/engine.py
index 823748ac..3e6016da 100644
--- a/src/ydata_quality/data_relations/engine.py
+++ b/src/ydata_quality/data_relations/engine.py
@@ -2,6 +2,7 @@
 Implementation of DataRelationsDetector engine to run data relations analysis.
 """
 from typing import Optional, Tuple, List
+from logging import _nameToLevel
 
 import numpy as np
 import pandas as pd
@@ -15,9 +16,13 @@ class DataRelationsDetector(QualityEngine):
     """Main class to run data relations analysis.
     """
 
-    def __init__(self):  # Overrides base class init
+    def __init__(self, severity: Optional[str] = None):  # Overrides base class init
+        "severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]"
         self._warnings = [] # reset the warnings to avoid duplicates
-        self._logger = create_logger(NAME, STREAM, LOG_LEVEL)
+        if severity in _nameToLevel:
+            os.environ["DQ_LOG_LEVEL"] = severity
+        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        self._logger = create_logger(NAME, STREAM, log_level)
 
     @property
     def tests(self):
diff --git a/src/ydata_quality/utils/logger.py b/src/ydata_quality/utils/logger.py
index 24a2474e..05dba78a 100644
--- a/src/ydata_quality/utils/logger.py
+++ b/src/ydata_quality/utils/logger.py
@@ -6,7 +6,6 @@
 # Default vars for the logger
 NAME = os.getenv('DQ_LOGGER_NAME', 'DQ_Logger')
 STREAM = sys.stdout
-LOG_LEVEL = os.getenv('DQ_LOG_LEVEL', logging.WARNING)
 
 def create_logger(name, stream: TextIO = sys.stdout, level=logging.INFO):
   handler = logging.StreamHandler(stream)

From 3f7a3751093a0d51febe99d505433c6f863856f4 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Wed, 22 Sep 2021 00:00:56 +0100
Subject: [PATCH 07/10] missing imports

---
 src/ydata_quality/core/data_quality.py        | 5 +++--
 src/ydata_quality/core/engine.py              | 6 +++---
 src/ydata_quality/data_expectations/engine.py | 5 +++--
 src/ydata_quality/data_relations/engine.py    | 5 +++--
 src/ydata_quality/duplicates/engine.py        | 1 +
 src/ydata_quality/erroneous_data/engine.py    | 2 +-
 6 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/ydata_quality/core/data_quality.py b/src/ydata_quality/core/data_quality.py
index ef5f7ed0..d475fd02 100644
--- a/src/ydata_quality/core/data_quality.py
+++ b/src/ydata_quality/core/data_quality.py
@@ -3,6 +3,7 @@
 """
 from collections import Counter
 from logging import _nameToLevel
+import os
 from typing import Callable, List, Optional, Union
 
 import pandas as pd
@@ -16,7 +17,7 @@
 from ydata_quality.data_expectations import DataExpectationsReporter
 from ydata_quality.bias_fairness import BiasFairness
 from ydata_quality.data_relations import DataRelationsDetector
-from ydata_quality.utils.logger import *
+from ydata_quality.utils.logger import create_logger, NAME, STREAM
 
 class DataQuality:
     "DataQuality contains the multiple data quality engines."
@@ -80,7 +81,7 @@ def __init__(self,
         self._warnings = list()
         if severity in _nameToLevel:
             os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
         self._logger = create_logger(NAME, STREAM, log_level)
         self._random_state = random_state
 
diff --git a/src/ydata_quality/core/engine.py b/src/ydata_quality/core/engine.py
index f669407e..be9c4524 100644
--- a/src/ydata_quality/core/engine.py
+++ b/src/ydata_quality/core/engine.py
@@ -12,7 +12,7 @@
 
 from ydata_quality.core.warnings import Priority, QualityWarning
 from ydata_quality.utils.auxiliary import infer_df_type, infer_dtypes
-from ydata_quality.utils.logger import *
+from ydata_quality.utils.logger import create_logger, NAME, STREAM
 
 
 class QualityEngine(ABC):
@@ -24,7 +24,7 @@ def __init__(self, df: pd.DataFrame, random_state: Optional[int] = None, label:
         self._warnings = list()
         if severity in _nameToLevel:
             os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
         self._logger = create_logger(NAME, STREAM, log_level)
         self._tests = []
         self._label = label
@@ -143,6 +143,6 @@ def evaluate(self):
             try: # if anything fails
                 results[test] = getattr(self, test)()
             except Exception as exc: # print a Warning and log the message
-                self._logger.warning('Skipping test due to failure during computation. See results folder of this test for further details.')
+                self._logger.warning('Skipping %s due to failure during computation. See results folder of this test for further details.', test)
                 results[test] = "[ERROR] Test failed to compute. Original exception: "+f"{exc}"
         return results
diff --git a/src/ydata_quality/data_expectations/engine.py b/src/ydata_quality/data_expectations/engine.py
index 82468f5f..295490a7 100644
--- a/src/ydata_quality/data_expectations/engine.py
+++ b/src/ydata_quality/data_expectations/engine.py
@@ -1,6 +1,7 @@
 """
 Implementation of DataExpectationsReporter engine to run data expectations validation analysis.
 """
+import os
 from typing import Optional
 from logging import _nameToLevel
 
@@ -9,7 +10,7 @@
 
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.auxiliary import test_load_json_path
-from ydata_quality.utils.logger import *
+from ydata_quality.utils.logger import create_logger, NAME, STREAM
 
 
 class DataExpectationsReporter(QualityEngine):
@@ -22,7 +23,7 @@ def __init__(self, severity: Optional[str]= None):  # Overrides base class init
         self._warnings = [] # reset the warnings to avoid duplicates
         if severity in _nameToLevel:
             os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
         self._logger = create_logger(NAME, STREAM, log_level)
 
     @property
diff --git a/src/ydata_quality/data_relations/engine.py b/src/ydata_quality/data_relations/engine.py
index 3e6016da..c3fa5673 100644
--- a/src/ydata_quality/data_relations/engine.py
+++ b/src/ydata_quality/data_relations/engine.py
@@ -1,6 +1,7 @@
 """
 Implementation of DataRelationsDetector engine to run data relations analysis.
 """
+import os
 from typing import Optional, Tuple, List
 from logging import _nameToLevel
 
@@ -10,7 +11,7 @@
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.correlations import correlation_matrix, partial_correlation_matrix, correlation_plotter, vif_collinearity, chi2_collinearity
 from ydata_quality.utils.auxiliary import infer_dtypes, standard_normalize
-from ydata_quality.utils.logger import *
+from ydata_quality.utils.logger import create_logger, NAME, STREAM
 
 class DataRelationsDetector(QualityEngine):
     """Main class to run data relations analysis.
@@ -21,7 +22,7 @@ def __init__(self, severity: Optional[str] = None):  # Overrides base class init
         self._warnings = [] # reset the warnings to avoid duplicates
         if severity in _nameToLevel:
             os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', logging.INFO)
+        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
         self._logger = create_logger(NAME, STREAM, log_level)
 
     @property
diff --git a/src/ydata_quality/duplicates/engine.py b/src/ydata_quality/duplicates/engine.py
index ffb8616c..184be425 100644
--- a/src/ydata_quality/duplicates/engine.py
+++ b/src/ydata_quality/duplicates/engine.py
@@ -15,6 +15,7 @@ class DuplicateChecker(QualityEngine):
 
     def __init__(self, df: pd.DataFrame, entities: List[Union[str, List[str]]] = [], is_close: bool=False):
         """
+        Arguments:
             df (pd.DataFrame): reference DataFrame used to run the DataQuality analysis.
             entities (List[Union[str, List[str]]]): entities relevant for duplicate analysis. Passing lists allows composed entities of multiple columns.
             is_close (bool): Pass True to use numpy.isclose instead of pandas.equals in column comparison."""
diff --git a/src/ydata_quality/erroneous_data/engine.py b/src/ydata_quality/erroneous_data/engine.py
index 25b6b7ff..f3a3884c 100644
--- a/src/ydata_quality/erroneous_data/engine.py
+++ b/src/ydata_quality/erroneous_data/engine.py
@@ -83,7 +83,7 @@ def flatlines(self, th: int=5, skip: list=[]):
             skip: List of columns that will not be target of search for flatlines.
                 Pass '__index' inside skip list to skip looking for flatlines at the index."""
         if self.df_type == DataFrameType.TABULAR:
-            self._logger.info('The provided DataFrame is not a valid Timeseries type, skipping this test.')
+            self._logger.debug('The provided DataFrame is not a valid Timeseries type, skipping flatlines test.')
             return None
         flatlines = {}
         for column in self.df.columns:  # Compile flatline index

From 47283659739f0c88ad3de05c954d4d076e0eccd9 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Wed, 22 Sep 2021 10:48:20 +0100
Subject: [PATCH 08/10] simplify logger instantiation

---
 src/ydata_quality/bias_fairness/engine.py     | 10 +++---
 src/ydata_quality/core/data_quality.py        | 31 +++++++++----------
 src/ydata_quality/core/engine.py              |  9 ++----
 src/ydata_quality/data_expectations/engine.py |  9 ++----
 src/ydata_quality/data_relations/engine.py    |  9 ++----
 src/ydata_quality/drift/engine.py             |  5 +--
 src/ydata_quality/duplicates/engine.py        |  7 +++--
 src/ydata_quality/erroneous_data/engine.py    |  5 +--
 src/ydata_quality/labelling/engine.py         | 31 ++++++++++++-------
 src/ydata_quality/missings/engine.py          |  5 +--
 src/ydata_quality/utils/logger.py             |  9 ++++--
 11 files changed, 66 insertions(+), 64 deletions(-)

diff --git a/src/ydata_quality/bias_fairness/engine.py b/src/ydata_quality/bias_fairness/engine.py
index 5c63ff09..2481acfe 100644
--- a/src/ydata_quality/bias_fairness/engine.py
+++ b/src/ydata_quality/bias_fairness/engine.py
@@ -22,14 +22,16 @@ class BiasFairness(QualityEngine):
     """
 
     def __init__(self, df: pd.DataFrame, sensitive_features: List[str], label: Optional[str] = None,
-        random_state: Optional[int] = None):
+        random_state: Optional[int] = None, severity: Optional[str]= None):
         """
         Args
             df (pd.DataFrame): reference DataFrame used to run the analysis
             sensitive_features (List[str]): features deemed as sensitive attributes
             label (str, optional): target feature to be predicted
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels
+                [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
-        super().__init__(df=df, label=label, random_state=random_state)
+        super().__init__(df=df, label=label, random_state=random_state, severity=severity)
         self._sensitive_features = sensitive_features
         self._tests = ["performance_discrimination", "proxy_identification",
                         "sensitive_predictability", "sensitive_representativity"]
@@ -72,7 +74,7 @@ def sensitive_predictability(self, th=0.5, adjusted_metric=True):
         performances = pd.Series(index=self.sensitive_features)
         for feat in performances.index:
             data = self.df.drop(columns=[x for x in drop_features if x != feat]) # drop all except target
-            performances[feat] = baseline_performance(df=data, target=feat, adjusted_metric=adjusted_metric)
+            performances[feat] = baseline_performance(df=data, label=feat, adjusted_metric=adjusted_metric)
 
         high_perfs = performances[performances>th]
         if len(high_perfs) > 0:
@@ -97,7 +99,7 @@ def performance_discrimination(self):
 
         res = {}
         for feat in self.sensitive_features:
-            res[feat] = pd.Series(performance_per_feature_values(df=self.df, feature=feat, target=self.label))
+            res[feat] = pd.Series(performance_per_feature_values(df=self.df, feature=feat, label=self.label))
         return res
 
 
diff --git a/src/ydata_quality/core/data_quality.py b/src/ydata_quality/core/data_quality.py
index d475fd02..1558a3df 100644
--- a/src/ydata_quality/core/data_quality.py
+++ b/src/ydata_quality/core/data_quality.py
@@ -2,8 +2,6 @@
 Implementation of main class for Data Quality checks.
 """
 from collections import Counter
-from logging import _nameToLevel
-import os
 from typing import Callable, List, Optional, Union
 
 import pandas as pd
@@ -17,7 +15,7 @@
 from ydata_quality.data_expectations import DataExpectationsReporter
 from ydata_quality.bias_fairness import BiasFairness
 from ydata_quality.data_relations import DataRelationsDetector
-from ydata_quality.utils.logger import create_logger, NAME, STREAM
+from ydata_quality.utils.logger import get_logger, NAME
 
 class DataQuality:
     "DataQuality contains the multiple data quality engines."
@@ -41,7 +39,7 @@ def __init__(self,
                     vif_th: float = 5,
                     p_th: float = 0.05,
                     plot: bool = True,
-                    severity: Optional[str]= 'ERROR'):
+                    severity: str= 'ERROR'):
         """
         Engines:
         - Duplicates
@@ -74,25 +72,22 @@ def __init__(self,
             vif_th (float): [DATA RELATIONS] Variance Inflation Factor threshold for numerical independence test, typically 5-10 is recommended. Defaults to 5.
             p_th (float): [DATA RELATIONS] Fraction of the right tail of the chi squared CDF defining threshold for categorical independence test. Defaults to 0.05.
             plot (bool): Pass True to produce all available graphical outputs, False to suppress all graphical output.
-            severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
+            severity (str): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
         #TODO: Refactor legacy engines (property based) and logic in this class to new base (lean objects)
         self.df = df
         self._warnings = list()
-        if severity in _nameToLevel:
-            os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
-        self._logger = create_logger(NAME, STREAM, log_level)
+        self._logger = get_logger(NAME, level=severity)
         self._random_state = random_state
 
         self._engines_legacy = { # Default list of engines
-            'duplicates': DuplicateChecker(df=df, entities=entities, is_close=is_close),
-            'missings': MissingsProfiler(df=df, label=label, random_state=self.random_state),
-            'erroneous-data': ErroneousDataIdentifier(df=df, ed_extensions=ed_extensions),
-            'drift': DriftAnalyser(ref=df, sample=sample, label=label, model=model, random_state=self.random_state)
+            'duplicates': DuplicateChecker(df=df, entities=entities, is_close=is_close, severity=severity),
+            'missings': MissingsProfiler(df=df, label=label, random_state=self.random_state, severity=severity),
+            'erroneous-data': ErroneousDataIdentifier(df=df, ed_extensions=ed_extensions, severity=severity),
+            'drift': DriftAnalyser(ref=df, sample=sample, label=label, model=model, random_state=self.random_state, severity=severity)
         }
 
-        self._engines_new = {'data-relations': DataRelationsDetector()}
+        self._engines_new = {'data-relations': DataRelationsDetector(severity=severity)}
         self._eval_args = { # Argument lists for different engines
         # TODO: centralize shared args in a dictionary to pass just like a regular kwargs to engines, pass specific args in arg list (define here)
         # In new standard all engines can be run at the evaluate method only, the evaluate run expression can then be:
@@ -103,16 +98,18 @@ def __init__(self,
 
         # Engines based on mandatory arguments
         if label is not None:
-            self._engines_legacy['labelling'] = LabelInspector(df=df, label=label, random_state=self.random_state)
+            self._engines_legacy['labelling'] = LabelInspector(df=df, label=label,
+                                                               random_state=self.random_state, severity=severity)
         else:
             self._logger.warning('Label is not defined. Skipping LABELLING engine.')
         if len(sensitive_features)>0:
             self._engines_legacy['bias&fairness'] = BiasFairness(df=df, sensitive_features=sensitive_features,
-                                                                 label=label, random_state=self.random_state)
+                                                                 label=label, random_state=self.random_state,
+                                                                 severity=severity)
         else:
             self._logger.warning('Sensitive features not defined. Skipping BIAS & FAIRNESS engine.')
         if results_json_path is not None:
-            self._engines_new['expectations'] = DataExpectationsReporter()
+            self._engines_new['expectations'] = DataExpectationsReporter(severity=severity)
         else:
             self._logger.warning('The path to a Great Expectations results json is not defined. Skipping EXPECTATIONS engine.')
 
diff --git a/src/ydata_quality/core/engine.py b/src/ydata_quality/core/engine.py
index be9c4524..cab7d037 100644
--- a/src/ydata_quality/core/engine.py
+++ b/src/ydata_quality/core/engine.py
@@ -4,15 +4,13 @@
 from abc import ABC
 from collections import Counter
 from typing import Optional
-import os
-from logging import _nameToLevel
 
 import pandas as pd
 from numpy import random
 
 from ydata_quality.core.warnings import Priority, QualityWarning
 from ydata_quality.utils.auxiliary import infer_df_type, infer_dtypes
-from ydata_quality.utils.logger import create_logger, NAME, STREAM
+from ydata_quality.utils.logger import get_logger, NAME
 
 
 class QualityEngine(ABC):
@@ -22,10 +20,7 @@ def __init__(self, df: pd.DataFrame, random_state: Optional[int] = None, label:
         self._df = df
         self._df_type = None
         self._warnings = list()
-        if severity in _nameToLevel:
-            os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
-        self._logger = create_logger(NAME, STREAM, log_level)
+        self._logger = get_logger(NAME, level=severity)
         self._tests = []
         self._label = label
         self._dtypes = dtypes
diff --git a/src/ydata_quality/data_expectations/engine.py b/src/ydata_quality/data_expectations/engine.py
index 295490a7..1cdd8e82 100644
--- a/src/ydata_quality/data_expectations/engine.py
+++ b/src/ydata_quality/data_expectations/engine.py
@@ -1,16 +1,14 @@
 """
 Implementation of DataExpectationsReporter engine to run data expectations validation analysis.
 """
-import os
 from typing import Optional
-from logging import _nameToLevel
 
 import numpy as np
 import pandas as pd
 
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.auxiliary import test_load_json_path
-from ydata_quality.utils.logger import create_logger, NAME, STREAM
+from ydata_quality.utils.logger import get_logger, NAME
 
 
 class DataExpectationsReporter(QualityEngine):
@@ -21,10 +19,7 @@ class DataExpectationsReporter(QualityEngine):
     def __init__(self, severity: Optional[str]= None):  # Overrides base class init
         "severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]"
         self._warnings = [] # reset the warnings to avoid duplicates
-        if severity in _nameToLevel:
-            os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
-        self._logger = create_logger(NAME, STREAM, log_level)
+        self._logger = get_logger(NAME, level=severity)
 
     @property
     def tests(self):
diff --git a/src/ydata_quality/data_relations/engine.py b/src/ydata_quality/data_relations/engine.py
index c3fa5673..28f3a47b 100644
--- a/src/ydata_quality/data_relations/engine.py
+++ b/src/ydata_quality/data_relations/engine.py
@@ -1,9 +1,7 @@
 """
 Implementation of DataRelationsDetector engine to run data relations analysis.
 """
-import os
 from typing import Optional, Tuple, List
-from logging import _nameToLevel
 
 import numpy as np
 import pandas as pd
@@ -11,7 +9,7 @@
 from ydata_quality.core import QualityEngine, QualityWarning
 from ydata_quality.utils.correlations import correlation_matrix, partial_correlation_matrix, correlation_plotter, vif_collinearity, chi2_collinearity
 from ydata_quality.utils.auxiliary import infer_dtypes, standard_normalize
-from ydata_quality.utils.logger import create_logger, NAME, STREAM
+from ydata_quality.utils.logger import get_logger, NAME
 
 class DataRelationsDetector(QualityEngine):
     """Main class to run data relations analysis.
@@ -20,10 +18,7 @@ class DataRelationsDetector(QualityEngine):
     def __init__(self, severity: Optional[str] = None):  # Overrides base class init
         "severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]"
         self._warnings = [] # reset the warnings to avoid duplicates
-        if severity in _nameToLevel:
-            os.environ["DQ_LOG_LEVEL"] = severity
-        log_level = os.getenv('DQ_LOG_LEVEL', _nameToLevel['INFO'])
-        self._logger = create_logger(NAME, STREAM, log_level)
+        self._logger = get_logger(NAME, level=severity)
 
     @property
     def tests(self):
diff --git a/src/ydata_quality/drift/engine.py b/src/ydata_quality/drift/engine.py
index 1edeb219..640c4b18 100644
--- a/src/ydata_quality/drift/engine.py
+++ b/src/ydata_quality/drift/engine.py
@@ -70,7 +70,7 @@ class DriftAnalyser(QualityEngine):
 
     def __init__(self, ref: pd.DataFrame, sample: Optional[pd.DataFrame] = None,
         label: Optional[str] = None, model: Optional[Union[Callable, ModelWrapper]] = None, holdout: float = 0.2,
-        random_state: Optional[int] = None):
+        random_state: Optional[int] = None, severity:Optional[str]=None):
         """
         Initializes the engine properties and lists tests for automated evaluation.
         Args:
@@ -84,8 +84,9 @@ def __init__(self, ref: pd.DataFrame, sample: Optional[pd.DataFrame] = None,
             holdout (float): Fraction to be kept as holdout for drift test.
             random_state (Optional, int): Seed used to guarantee reproducibility of the random sample splits.
                 Pass None for no reproducibility.
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
-        super().__init__(df=ref, label=label, random_state=random_state)
+        super().__init__(df=ref, label=label, random_state=random_state, severity=severity)
         self.sample = sample
         self.model = model
         self._holdout, self._remaining_data = random_split(ref, holdout, random_state=self.random_state)
diff --git a/src/ydata_quality/duplicates/engine.py b/src/ydata_quality/duplicates/engine.py
index 184be425..d0278684 100644
--- a/src/ydata_quality/duplicates/engine.py
+++ b/src/ydata_quality/duplicates/engine.py
@@ -13,13 +13,14 @@
 class DuplicateChecker(QualityEngine):
     "Engine for running analyis on duplicate records."
 
-    def __init__(self, df: pd.DataFrame, entities: List[Union[str, List[str]]] = [], is_close: bool=False):
+    def __init__(self, df: pd.DataFrame, entities: List[Union[str, List[str]]] = [], is_close: bool=False, severity: Optional[str]= None):
         """
         Arguments:
             df (pd.DataFrame): reference DataFrame used to run the DataQuality analysis.
             entities (List[Union[str, List[str]]]): entities relevant for duplicate analysis. Passing lists allows composed entities of multiple columns.
-            is_close (bool): Pass True to use numpy.isclose instead of pandas.equals in column comparison."""
-        super().__init__(df=df)
+            is_close (bool): Pass True to use numpy.isclose instead of pandas.equals in column comparison.
+            severity (str): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]"""
+        super().__init__(df=df, severity=severity)
         self._entities = entities
         self._tests = ["exact_duplicates", "entity_duplicates", "duplicate_columns"]
         self._is_close = is_close
diff --git a/src/ydata_quality/erroneous_data/engine.py b/src/ydata_quality/erroneous_data/engine.py
index f3a3884c..ab9483be 100644
--- a/src/ydata_quality/erroneous_data/engine.py
+++ b/src/ydata_quality/erroneous_data/engine.py
@@ -13,13 +13,14 @@
 class ErroneousDataIdentifier(QualityEngine):
     "Engine for running analysis on erroneous data."
 
-    def __init__(self, df: pd.DataFrame, ed_extensions: Optional[list]=[]):
+    def __init__(self, df: pd.DataFrame, ed_extensions: Optional[list]=[], severity:Optional[str]=None):
         """
         Args:
             df (pd.DataFrame): DataFrame used to run the erroneous data analysis.
             ed_extensions: A list of user provided erroneous data values to append to defaults.
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
-        super().__init__(df=df)
+        super().__init__(df=df, severity=severity)
         if self.df_type == DataFrameType.TIMESERIES:
             self._tests = ["flatlines", "predefined_erroneous_data"]
         else:
diff --git a/src/ydata_quality/labelling/engine.py b/src/ydata_quality/labelling/engine.py
index 98585ab4..32c26e67 100644
--- a/src/ydata_quality/labelling/engine.py
+++ b/src/ydata_quality/labelling/engine.py
@@ -14,20 +14,29 @@
                                            standard_transform)
 
 
-def LabelInspector(df, label, random_state: Optional[int]=None):
-    """Instantiate this label inspector class.
-    Runs a label type inference to instantiate the correct label inspector."""
+def LabelInspector(df, label, random_state: Optional[int]=None, severity:Optional[str]=None):
+    """Runs a label type inference to instantiate the correct label inspector.
+    Instantiate this label inspector method to create a Label Inspector.
+
+    Arguments:
+            df (pd.DataFrame): reference DataFrame used to run the label analysis.
+            label (str, optional): target feature to be predicted.
+            random_state (int, optional): Integer seed for random reproducibility. Default is None.
+                Set to None for fully random behavior, no reproducibility.
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels
+                [DEBUG, INFO, WARNING, ERROR, CRITICAL]
+        """
     label_dtype = infer_dtypes(df[label])[label]  # Label column dtype inferral
     if label_dtype == 'categorical':
-        return CategoricalLabelInspector(df, label, random_state=random_state)
+        return CategoricalLabelInspector(df, label, random_state=random_state, severity=severity)
     else:
-        return NumericalLabelInspector(df, label, random_state=random_state)
+        return NumericalLabelInspector(df, label, random_state=random_state, severity=severity)
 
 class SharedLabelInspector(QualityEngine):
     """Shared structure for Numerical/Categorical Label Inspector"""
 
-    def __init__(self, df: pd.DataFrame, label: str, random_state: Optional[int]=None):
-        super().__init__(df=df, label=label, random_state=random_state)
+    def __init__(self, df: pd.DataFrame, label: str, random_state: Optional[int]=None, severity:Optional[str]=None):
+        super().__init__(df=df, label=label, random_state=random_state, severity=severity)
         self._tdf = None
 
     @property
@@ -70,8 +79,8 @@ class CategoricalLabelInspector(SharedLabelInspector):
     """Engine for running analysis on categorical labels.
     Ordinal labels can be handled if passed as categorical."""
 
-    def __init__(self, df: pd.DataFrame, label: str, random_state: Optional[int]):
-        super().__init__(df=df, label=label, random_state=random_state)
+    def __init__(self, df: pd.DataFrame, label: str, random_state: Optional[int], severity:Optional[str]=None):
+        super().__init__(df=df, label=label, random_state=random_state, severity = severity)
         self._centroids = None
         self._tests = ["missing_labels", "few_labels", "unbalanced_classes",
         "one_vs_rest_performance", "outlier_detection"]
@@ -235,8 +244,8 @@ def outlier_detection(self, th=3):
 class NumericalLabelInspector(SharedLabelInspector):
     "Engine for running analyis on numerical labels."
 
-    def __init__(self, df: pd.DataFrame, label: str, random_state):
-        super().__init__(df=df, label=label, random_state=random_state)
+    def __init__(self, df: pd.DataFrame, label: str, random_state, severity:Optional[str]=None):
+        super().__init__(df=df, label=label, random_state=random_state, severity = severity)
         self._tests = ["missing_labels", "test_normality", "outlier_detection"]
 
     def _GMM_clusters(self, max_clusters):
diff --git a/src/ydata_quality/missings/engine.py b/src/ydata_quality/missings/engine.py
index 992e0af0..b1949297 100644
--- a/src/ydata_quality/missings/engine.py
+++ b/src/ydata_quality/missings/engine.py
@@ -15,15 +15,16 @@
 class MissingsProfiler(QualityEngine):
     "Main class to run missing value analysis."
 
-    def __init__(self, df: pd.DataFrame, label: Optional[str] = None, random_state: Optional[int]=None):
+    def __init__(self, df: pd.DataFrame, label: Optional[str] = None, random_state: Optional[int]=None, severity: Optional[str]= None):
         """
         Args:
             df (pd.DataFrame): reference DataFrame used to run the missing value analysis.
             label (str, optional): target feature to be predicted.
             random_state (int, optional): Integer seed for random reproducibility. Default is None.
                 Set to None for fully random behavior, no reproducibility.
+            severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
-        super().__init__(df=df, random_state=random_state)
+        super().__init__(df=df, random_state=random_state, severity=severity)
         self._label = label
         self._tests = ["nulls_higher_than", "high_missing_correlations", "predict_missings"]
 
diff --git a/src/ydata_quality/utils/logger.py b/src/ydata_quality/utils/logger.py
index 05dba78a..0057eddf 100644
--- a/src/ydata_quality/utils/logger.py
+++ b/src/ydata_quality/utils/logger.py
@@ -2,12 +2,16 @@
 from typing import TextIO
 import sys
 import os
+from logging import _nameToLevel
 
 # Default vars for the logger
 NAME = os.getenv('DQ_LOGGER_NAME', 'DQ_Logger')
-STREAM = sys.stdout
 
-def create_logger(name, stream: TextIO = sys.stdout, level=logging.INFO):
+def get_logger(name, stream: TextIO = sys.stdout, level: str=logging.INFO):
+  acceptable_levels = [None]+list(_nameToLevel.keys())
+  assert level in acceptable_levels, "Valid levels for warning severity are {}. Defaults to info level.".format(acceptable_levels)
+  if not level:
+    level = logging.INFO  # Default threshold
   handler = logging.StreamHandler(stream)
   handler.setFormatter(
       logging.Formatter(
@@ -22,3 +26,4 @@ def create_logger(name, stream: TextIO = sys.stdout, level=logging.INFO):
   logger.propagate = False
 
   return logger
+

From 4c592726fdf03ccc349cfed3135a78a9bf6358e6 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Wed, 22 Sep 2021 10:53:00 +0100
Subject: [PATCH 09/10] Fix unnecessary setting of label outside of super

---
 src/ydata_quality/missings/engine.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/ydata_quality/missings/engine.py b/src/ydata_quality/missings/engine.py
index b1949297..b20bf5d9 100644
--- a/src/ydata_quality/missings/engine.py
+++ b/src/ydata_quality/missings/engine.py
@@ -24,8 +24,7 @@ def __init__(self, df: pd.DataFrame, label: Optional[str] = None, random_state:
                 Set to None for fully random behavior, no reproducibility.
             severity (str, optional): Sets the logger warning threshold to one of the valid levels [DEBUG, INFO, WARNING, ERROR, CRITICAL]
         """
-        super().__init__(df=df, random_state=random_state, severity=severity)
-        self._label = label
+        super().__init__(df=df, random_state=random_state, label=label, severity=severity)
         self._tests = ["nulls_higher_than", "high_missing_correlations", "predict_missings"]
 
     def _get_null_cols(self, col: Optional[str] = None) -> List[str]:

From 59cb4e41935f3a0898de2866437db92a655dcd60 Mon Sep 17 00:00:00 2001
From: Francisco Santos <francisco.santos@ydata.ai>
Date: Wed, 22 Sep 2021 11:58:35 +0100
Subject: [PATCH 10/10] up a log to warning

---
 src/ydata_quality/duplicates/engine.py | 2 +-
 src/ydata_quality/utils/logger.py      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/ydata_quality/duplicates/engine.py b/src/ydata_quality/duplicates/engine.py
index d0278684..38e81ddf 100644
--- a/src/ydata_quality/duplicates/engine.py
+++ b/src/ydata_quality/duplicates/engine.py
@@ -98,7 +98,7 @@ def entity_duplicates(self, entity: Optional[Union[str, List[str]]] = None):
                     ent_dups.setdefault(entity_key, {})[val] = dups[(dups[entity].values==val).all(axis=1)]
         else: # if entity is not specified
             if len(self.entities) == 0:
-                self._logger.info("There are no entities defined to run the analysis. Skipping the test.")
+                self._logger.warning("There are no entities defined to run the analysis. Skipping the test.")
                 return None
             else:
                 for col in self.entities:
diff --git a/src/ydata_quality/utils/logger.py b/src/ydata_quality/utils/logger.py
index 0057eddf..2801bb23 100644
--- a/src/ydata_quality/utils/logger.py
+++ b/src/ydata_quality/utils/logger.py
@@ -9,7 +9,7 @@
 
 def get_logger(name, stream: TextIO = sys.stdout, level: str=logging.INFO):
   acceptable_levels = [None]+list(_nameToLevel.keys())
-  assert level in acceptable_levels, "Valid levels for warning severity are {}. Defaults to info level.".format(acceptable_levels)
+  assert level in acceptable_levels, f"Valid levels for warning severity are {acceptable_levels}. Defaults to info level."
   if not level:
     level = logging.INFO  # Default threshold
   handler = logging.StreamHandler(stream)