feat: initial release

Author: Pkcha

src/ydata_profiling/model/handler.py

@@ -1,79 +1,80 @@
 """
     Auxiliary handler methods for data summary extraction
 """
-from typing import Any, Callable, Dict, List, Sequence, Tuple, TypeVar, cast
+from typing import Any, Callable, Dict, List, Sequence, Tuple, Union
 
 import networkx as nx
 from visions import VisionsTypeset
 
-T = TypeVar("T")
-SummaryFunction = Callable[..., Tuple[Any, ...]]
 
-
-def compose(functions: Sequence[SummaryFunction]) -> SummaryFunction:
+def compose(functions: Sequence[Callable]) -> Callable:
     """
     Compose a sequence of functions.
 
-    :param functions: sequence of functions
-    :return: combined function applying all functions in order.
+    Each function in the sequence receives the result of the previous function.
+    Functions are expected to accept and return tuples for proper chaining.
+
+    :param functions: sequence of functions that accept and return tuples
+    :return: combined function applying all functions in order
     """
 
     def composed_function(*args: Any) -> Tuple[Any, ...]:
-        result: Tuple[Any, ...] = args
+        result: Union[Tuple[Any, ...], Any] = args
         for func in functions:
-            step_result = func(*result)
-            if not isinstance(step_result, tuple):
-                result = (step_result,)
+            if isinstance(result, tuple):
+                result = func(*result)
             else:
-                result = step_result
-        return result
+                result = func(result)
+        if isinstance(result, tuple):
+            return result
+        return (result,)
 
     return composed_function
 
 
 class Handler:
     """A generic handler
 
-    Allows any custom mapping between data types and functions
+    Allows any custom mapping between data types and functions.
+    Functions are composed based on the type hierarchy defined in the typeset.
     """
 
     def __init__(
         self,
-        mapping: Dict[str, List[SummaryFunction]],
+        mapping: Dict[str, List[Callable]],
         typeset: VisionsTypeset,
         *args: Any,
-        **kwargs: Any,
-    ) -> None:
-        self.mapping: Dict[str, List[SummaryFunction]] = mapping
+        **kwargs: Any
+    ):
+        self.mapping = mapping
         self.typeset = typeset
         self._complete_dag()
 
     def _complete_dag(self) -> None:
         for from_type, to_type in nx.topological_sort(
             nx.line_graph(self.typeset.base_graph)
         ):
-            from_type_str = str(from_type)
-            to_type_str = str(to_type)
-            
-            if from_type_str not in self.mapping:
-                continue
-                
-            if to_type_str in self.mapping:
-                self.mapping[to_type_str] = (
-                    self.mapping[from_type_str] + self.mapping[to_type_str]
-                )
-            else:
-                self.mapping[to_type_str] = self.mapping[from_type_str].copy()
+            from_key = str(from_type)
+            to_key = str(to_type)
+            self.mapping[to_key] = self.mapping.get(from_key, []) + self.mapping.get(
+                to_key, []
+            )
 
     def handle(self, dtype: str, *args: Any, **kwargs: Any) -> Dict[str, Any]:
         """
-        Returns:
-            object: a tuple containing the config, the dataset series and the summary extracted
+        Execute the handler chain for the given data type.
+
+        :param dtype: the data type to handle
+        :param args: arguments to pass to the handler functions
+        :param kwargs: keyword arguments (currently unused but reserved for extensibility)
+        :return: a dictionary containing the summary extracted from the data
         """
         funcs = self.mapping.get(dtype, [])
         op = compose(funcs)
         result = op(*args)
-        return cast(Dict[str, Any], result[-1])
+        if result:
+            return result[-1] if isinstance(result[-1], dict) else {}
+        return {}
 
 
 def get_render_map() -> Dict[str, Callable]:

src/ydata_profiling/model/pandas/describe_categorical_pandas.py

@@ -27,6 +27,7 @@ def get_character_counts_vc(vc: pd.Series) -> pd.Series:
     if len(counts) > 0:
         counts = counts.groupby(level=0, sort=False).sum()
         counts = counts.sort_values(ascending=False)
+        # FIXME: correct in split, below should be zero: print(counts.loc[''])
         counts = counts[counts.index.str.len() > 0]
     return counts
 

src/ydata_profiling/model/spark/missing_spark.py

@@ -82,11 +82,9 @@ def missing_matrix(config: Settings, df: DataFrame) -> str:
 def missing_heatmap(config: Settings, df: DataFrame) -> str:
     df = MissingnoBarSparkPatch(df, columns=df.columns, original_df_size=df.count())
 
-    # Remove completely filled or completely empty variables.
     columns = [i for i, n in enumerate(np.var(df.isnull(), axis="rows")) if n > 0]
     df = df.iloc[:, columns]
 
-    # Create and mask the correlation matrix. Construct the base heatmap.
     corr_mat = df.isnull().corr()
     mask = np.zeros_like(corr_mat)
     mask[np.triu_indices_from(mask)] = True

src/ydata_profiling/report/presentation/core/collapse.py

@@ -6,7 +6,7 @@
 
 
 class Collapse(ItemRenderer):
-    def __init__(self, button: ToggleButton, item: Renderable, **kwargs: Any):
+    def __init__(self, button: ToggleButton, item: Renderable, **kwargs):
         super().__init__("collapse", {"button": button, "item": item}, **kwargs)
 
     def __repr__(self) -> str:

src/ydata_profiling/report/presentation/core/container.py

@@ -13,7 +13,7 @@ def __init__(
         anchor_id: Optional[str] = None,
         classes: Optional[str] = None,
         oss: Optional[bool] = None,
-        **kwargs: Any,
+        **kwargs,
     ):
         args = {"items": items, "nested": nested}
         args.update(**kwargs)

src/ydata_profiling/report/presentation/core/dropdown.py

@@ -15,7 +15,7 @@ def __init__(
         anchor_id: str,
         classes: list,
         is_row: bool,
-        **kwargs: Any,
+        **kwargs
     ):
         super().__init__(
             "dropdown",

src/ydata_profiling/report/presentation/core/renderable.py

@@ -1,5 +1,5 @@
 from abc import ABC, abstractmethod
-from typing import Any, Callable, Dict, Optional
+from typing import Any, Dict, Optional
 
 
 class Renderable(ABC):
@@ -38,5 +38,5 @@ def __str__(self) -> str:
         return self.__class__.__name__
 
     @classmethod
-    def convert_to_class(cls, obj: "Renderable", flavour_func: Callable) -> None:
+    def convert_to_class(cls, obj: "Renderable", flavour_func) -> None:
         obj.__class__ = cls

src/ydata_profiling/report/presentation/core/root.py

@@ -11,7 +11,7 @@ class Root(ItemRenderer):
     """
 
     def __init__(
-        self, name: str, body: Renderable, footer: Renderable, style: Style, **kwargs: Any
+        self, name: str, body: Renderable, footer: Renderable, style: Style, **kwargs
     ):
         super().__init__(
             "report",
@@ -23,7 +23,7 @@ def __init__(
     def __repr__(self) -> str:
         return "Root"
 
-    def render(self, **kwargs: Any) -> Any:
+    def render(self, **kwargs) -> Any:
         raise NotImplementedError()
 
     @classmethod

src/ydata_profiling/report/presentation/core/variable.py

@@ -10,13 +10,13 @@ def __init__(
         top: Renderable,
         bottom: Optional[Renderable] = None,
         ignore: bool = False,
-        **kwargs: Any,
+        **kwargs,
     ):
         super().__init__(
             "variable", {"top": top, "bottom": bottom, "ignore": ignore}, **kwargs
         )
 
-    def __str__(self) -> str:
+    def __str__(self):
         top_text = str(self.content["top"]).replace("\n", "\n\t")
         bottom_text = str(self.content["bottom"]).replace("\n", "\n\t")
 
@@ -25,7 +25,7 @@ def __str__(self) -> str:
         text += f"- bottom: {bottom_text}"
         return text
 
-    def __repr__(self) -> str:
+    def __repr__(self):
         return "Variable"
 
     def render(self) -> Any:

src/ydata_profiling/report/presentation/flavours/flavour_html.py

@@ -41,10 +41,7 @@
     HTMLVariableInfo,
 )
 
-from typing import cast
-from ydata_profiling.report.presentation.flavours.flavours import _FlavourMapping
-
-html_mapping = cast(_FlavourMapping, {
+html_mapping = {
     Container: HTMLContainer,
     Variable: HTMLVariable,
     VariableInfo: HTMLVariableInfo,
@@ -62,6 +59,6 @@
     Collapse: HTMLCollapse,
     CorrelationTable: HTMLCorrelationTable,
     Scores: HTMLScores,
-})
+}
 
 register_flavour("html", html_mapping)