feat: refactor var description

src/ydata_profiling/model/alerts.py

@@ -9,6 +9,7 @@
 
 from ydata_profiling.config import Settings
 from ydata_profiling.model.correlations import perform_check_correlation
+from ydata_profiling.model.var_description.default import VarDescription
 from ydata_profiling.utils.styles import get_alert_styles
 
 
@@ -157,13 +158,13 @@ def __repr__(self):
 class ConstantLengthAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.CONSTANT_LENGTH,
-            values=values,
+            values=values.var_specific,
             column_name=column_name,
             fields={"composition_min_length", "composition_max_length"},
             is_empty=is_empty,
@@ -176,15 +177,17 @@ def _get_description(self) -> str:
 class ConstantAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.CONSTANT,
-            values=values,
+            values={
+                "n_distinct": values["n_distinct"],
+                "value_counts_without_nan": values.value_counts_without_nan,
+            },
             column_name=column_name,
-            fields={"n_distinct"},
             is_empty=is_empty,
         )
 
@@ -195,7 +198,7 @@ def _get_description(self) -> str:
 class DuplicatesAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: dict,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
@@ -239,15 +242,14 @@ def _get_description(self) -> str:
 class EmptyAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.EMPTY,
-            values=values,
+            values={"n": values.n},
             column_name=column_name,
-            fields={"n"},
             is_empty=is_empty,
         )
 
@@ -258,15 +260,14 @@ def _get_description(self) -> str:
 class HighCardinalityAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.HIGH_CARDINALITY,
-            values=values,
+            values={"n_distinct": values["n_distinct"]},
             column_name=column_name,
-            fields={"n_distinct"},
             is_empty=is_empty,
         )
 
@@ -302,7 +303,7 @@ def _get_description(self) -> str:
 class HighCorrelationAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: Dict,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
@@ -328,13 +329,13 @@ def _get_description(self) -> str:
 class ImbalanceAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.IMBALANCE,
-            values=values,
+            values=values.var_specific,
             column_name=column_name,
             fields={"imbalance"},
             is_empty=is_empty,
@@ -351,13 +352,13 @@ def _get_description(self) -> str:
 class InfiniteAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.INFINITE,
-            values=values,
+            values=values.var_specific,
             column_name=column_name,
             fields={"p_infinite", "n_infinite"},
             is_empty=is_empty,
@@ -373,15 +374,14 @@ def _get_description(self) -> str:
 class MissingAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.MISSING,
-            values=values,
+            values={"p_missing": values.p_missing, "n_missing": values.n_missing},
             column_name=column_name,
-            fields={"p_missing", "n_missing"},
             is_empty=is_empty,
         )
 
@@ -431,13 +431,13 @@ def _get_description(self) -> str:
 class SkewedAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.SKEWED,
-            values=values,
+            values=values.var_specific,
             column_name=column_name,
             fields={"skewness"},
             is_empty=is_empty,
@@ -490,15 +490,19 @@ def _get_description(self) -> str:
 class UniqueAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.UNIQUE,
-            values=values,
+            values={
+                "n_distinct": values["n_distinct"],
+                "p_distinct": values["p_distinct"],
+                "n_unique": values["n_unique"],
+                "p_unique": values["p_unique"],
+            },
             column_name=column_name,
-            fields={"n_distinct", "p_distinct", "n_unique", "p_unique"},
             is_empty=is_empty,
         )
 
@@ -527,13 +531,13 @@ def _get_description(self) -> str:
 class ZerosAlert(Alert):
     def __init__(
         self,
-        values: Optional[Dict] = None,
+        values: VarDescription,
         column_name: Optional[str] = None,
         is_empty: bool = False,
     ):
         super().__init__(
             alert_type=AlertType.ZEROS,
-            values=values,
+            values=values.var_specific,
             column_name=column_name,
             fields={"n_zeros", "p_zeros"},
             is_empty=is_empty,
@@ -589,7 +593,7 @@ def check_table_alerts(table: dict) -> List[Alert]:
     return alerts
 
 
-def numeric_alerts(config: Settings, summary: dict) -> List[Alert]:
+def numeric_alerts(config: Settings, summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = []
 
     # Skewness
@@ -613,7 +617,7 @@ def numeric_alerts(config: Settings, summary: dict) -> List[Alert]:
     return alerts
 
 
-def timeseries_alerts(config: Settings, summary: dict) -> List[Alert]:
+def timeseries_alerts(config: Settings, summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = numeric_alerts(config, summary)
 
     if not summary["stationary"]:
@@ -625,7 +629,7 @@ def timeseries_alerts(config: Settings, summary: dict) -> List[Alert]:
     return alerts
 
 
-def categorical_alerts(config: Settings, summary: dict) -> List[Alert]:
+def categorical_alerts(config: Settings, summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = []
 
     # High cardinality
@@ -643,7 +647,7 @@ def categorical_alerts(config: Settings, summary: dict) -> List[Alert]:
 
     # Constant length
     if "composition" in summary and summary["min_length"] == summary["max_length"]:
-        alerts.append(ConstantLengthAlert())
+        alerts.append(ConstantLengthAlert(summary))
 
     # Imbalance
     if (
@@ -654,32 +658,32 @@ def categorical_alerts(config: Settings, summary: dict) -> List[Alert]:
     return alerts
 
 
-def boolean_alerts(config: Settings, summary: dict) -> List[Alert]:
+def boolean_alerts(config: Settings, summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = []
 
     if (
         "imbalance" in summary
         and summary["imbalance"] > config.vars.bool.imbalance_threshold
     ):
-        alerts.append(ImbalanceAlert())
+        alerts.append(ImbalanceAlert(summary))
     return alerts
 
 
-def generic_alerts(summary: dict) -> List[Alert]:
+def generic_alerts(summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = []
 
     # Missing
-    if alert_value(summary["p_missing"]):
-        alerts.append(MissingAlert())
+    if alert_value(summary.p_missing):
+        alerts.append(MissingAlert(summary))
 
     return alerts
 
 
-def supported_alerts(summary: dict) -> List[Alert]:
+def supported_alerts(summary: VarDescription) -> List[Alert]:
     alerts: List[Alert] = []
 
-    if summary.get("n_distinct", np.nan) == summary["n"]:
-        alerts.append(UniqueAlert())
+    if summary.get("n_distinct", np.nan) == summary.n:
+        alerts.append(UniqueAlert(summary))
     if summary.get("n_distinct", np.nan) == 1:
         alerts.append(ConstantAlert(summary))
     return alerts
@@ -693,7 +697,9 @@ def unsupported_alerts() -> List[Alert]:
     return alerts
 
 
-def check_variable_alerts(config: Settings, col: str, description: dict) -> List[Alert]:
+def check_variable_alerts(
+    config: Settings, col: str, description: VarDescription
+) -> List[Alert]:
     """Checks individual variables for alerts.
 
     Args:
@@ -723,7 +729,6 @@ def check_variable_alerts(config: Settings, col: str, description: dict) -> List
 
     for idx in range(len(alerts)):
         alerts[idx].column_name = col
-        alerts[idx].values = description
     return alerts
 
 
@@ -751,7 +756,10 @@ def check_correlation_alerts(config: Settings, correlations: dict) -> List[Alert
 
 
 def get_alerts(
-    config: Settings, table_stats: dict, series_description: dict, correlations: dict
+    config: Settings,
+    table_stats: dict,
+    series_description: Dict[str, VarDescription],
+    correlations: dict,
 ) -> List[Alert]:
     alerts: List[Alert] = check_table_alerts(table_stats)
     for col, description in series_description.items():

src/ydata_profiling/model/describe.py

@@ -1,4 +1,5 @@
 """Organize the calculation of statistics for each series in this DataFrame."""
+
 from datetime import datetime
 from typing import Any, Dict, Optional, Union
 
@@ -23,6 +24,7 @@
 from ydata_profiling.model.summary import get_series_descriptions
 from ydata_profiling.model.table import get_table_stats
 from ydata_profiling.model.timeseries_index import get_time_index_description
+from ydata_profiling.model.var_description.default import VarDescription
 from ydata_profiling.utils.progress_bar import progress
 from ydata_profiling.version import __version__
 
@@ -86,7 +88,7 @@ def describe(
 
         # Variable-specific
         pbar.total += len(df.columns)
-        series_description = get_series_descriptions(
+        series_description: Dict[str, VarDescription] = get_series_descriptions(
             config, df, summarizer, typeset, pbar
         )
 

src/ydata_profiling/model/description.py

@@ -4,6 +4,8 @@
 
 from pandas import Timedelta
 
+from ydata_profiling.model.var_description.default import VarDescription
+
 
 @dataclass
 class BaseAnalysis:
@@ -98,7 +100,7 @@ class BaseDescription:
     analysis: BaseAnalysis
     time_index_analysis: Optional[TimeIndexAnalysis]
     table: Any
-    variables: Dict[str, Any]
+    variables: Dict[str, VarDescription]
     scatter: Any
     correlations: Dict[str, Any]
     missing: Dict[str, Any]