fg-data-profiling 4.19.0__py2.py3-none-any.whl

data_profiling/report/presentation/core/renderable.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional
+
+
+class Renderable(ABC):
+    def __init__(
+        self,
+        content: Dict[str, Any],
+        name: Optional[str] = None,
+        anchor_id: Optional[str] = None,
+        classes: Optional[str] = None,
+    ):
+        self.content = content
+        if name is not None:
+            self.content["name"] = name
+        if anchor_id is not None:
+            self.content["anchor_id"] = anchor_id
+        if classes is not None:
+            self.content["classes"] = classes
+
+    @property
+    def name(self) -> str:
+        return self.content["name"]
+
+    @property
+    def anchor_id(self) -> str:
+        return self.content["anchor_id"]
+
+    @property
+    def classes(self) -> str:
+        return self.content["classes"]
+
+    @abstractmethod
+    def render(self) -> Any:
+        pass
+
+    def __str__(self):
+        return self.__class__.__name__
+
+    @classmethod
+    def convert_to_class(cls, obj: "Renderable", flavour_func) -> None:  # noqa: ANN001
+        obj.__class__ = cls

data_profiling/report/presentation/core/root.py

@@ -0,0 +1,35 @@
+from typing import Any, Callable
+
+from data_profiling.config import Style
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+from data_profiling.report.presentation.core.renderable import Renderable
+
+
+class Root(ItemRenderer):
+    """
+    Wrapper for the report.
+    """
+
+    def __init__(
+        self, name: str, body: Renderable, footer: Renderable, style: Style, **kwargs
+    ):
+        super().__init__(
+            "report",
+            {"body": body, "footer": footer, "style": style},
+            name=name,
+            **kwargs
+        )
+
+    def __repr__(self) -> str:
+        return "Root"
+
+    def render(self, **kwargs) -> Any:
+        raise NotImplementedError()
+
+    @classmethod
+    def convert_to_class(cls, obj: Renderable, flv: Callable) -> None:
+        obj.__class__ = cls
+        if "body" in obj.content:
+            flv(obj.content["body"])
+        if "footer" in obj.content:
+            flv(obj.content["footer"])

data_profiling/report/presentation/core/sample.py

@@ -0,0 +1,20 @@
+from typing import Any, Optional
+
+import pandas as pd
+
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+
+
+class Sample(ItemRenderer):
+    def __init__(
+        self, name: str, sample: pd.DataFrame, caption: Optional[str] = None, **kwargs
+    ):
+        super().__init__(
+            "sample", {"sample": sample, "caption": caption}, name=name, **kwargs
+        )
+
+    def __repr__(self) -> str:
+        return "Sample"
+
+    def render(self) -> Any:
+        raise NotImplementedError()

data_profiling/report/presentation/core/scores.py

@@ -0,0 +1,32 @@
+"""
+    Scores ItemRendered class
+"""
+from typing import Any, Dict, List, Optional
+
+from data_profiling.config import Style
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+
+
+class Scores(ItemRenderer):
+    def __init__(
+        self,
+        items: List[Dict],
+        overall_score: float,
+        style: Style,
+        name: Optional[str],
+        **kwargs
+    ):
+        content = {
+            "items": items,
+            "overall_score": overall_score,
+            "name": name,
+            "style": style,
+        }
+
+        super().__init__("scores", content=content, **kwargs)
+
+    def __repr__(self) -> str:
+        return "Scores"
+
+    def render(self) -> Any:
+        raise NotImplementedError("Handled by flavour-specific class")

data_profiling/report/presentation/core/table.py

@@ -0,0 +1,26 @@
+from typing import Any, Optional, Sequence
+
+from data_profiling.config import Style
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+
+
+class Table(ItemRenderer):
+    def __init__(
+        self,
+        rows: Sequence,
+        style: Style,
+        name: Optional[str] = None,
+        caption: Optional[str] = None,
+        **kwargs
+    ):
+        super().__init__(
+            "table",
+            {"rows": rows, "name": name, "caption": caption, "style": style},
+            **kwargs
+        )
+
+    def __repr__(self) -> str:
+        return "Table"
+
+    def render(self) -> Any:
+        raise NotImplementedError()

data_profiling/report/presentation/core/toggle_button.py

@@ -0,0 +1,14 @@
+from typing import Any
+
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+
+
+class ToggleButton(ItemRenderer):
+    def __init__(self, text: str, **kwargs):
+        super().__init__("toggle_button", {"text": text}, **kwargs)
+
+    def __repr__(self) -> str:
+        return "ToggleButton"
+
+    def render(self) -> Any:
+        raise NotImplementedError()

data_profiling/report/presentation/core/variable.py

@@ -0,0 +1,40 @@
+from typing import Any, Callable, Optional
+
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+from data_profiling.report.presentation.core.renderable import Renderable
+
+
+class Variable(ItemRenderer):
+    def __init__(
+        self,
+        top: Renderable,
+        bottom: Optional[Renderable] = None,
+        ignore: bool = False,
+        **kwargs,
+    ):
+        super().__init__(
+            "variable", {"top": top, "bottom": bottom, "ignore": ignore}, **kwargs
+        )
+
+    def __str__(self):
+        top_text = str(self.content["top"]).replace("\n", "\n\t")
+        bottom_text = str(self.content["bottom"]).replace("\n", "\n\t")
+
+        text = "Variable\n"
+        text += f"- top: {top_text}"
+        text += f"- bottom: {bottom_text}"
+        return text
+
+    def __repr__(self):
+        return "Variable"
+
+    def render(self) -> Any:
+        raise NotImplementedError()
+
+    @classmethod
+    def convert_to_class(cls, obj: Renderable, flv: Callable) -> None:
+        obj.__class__ = cls
+        if "top" in obj.content and obj.content["top"] is not None:
+            flv(obj.content["top"])
+        if "bottom" in obj.content and obj.content["bottom"] is not None:
+            flv(obj.content["bottom"])

data_profiling/report/presentation/core/variable_info.py

@@ -0,0 +1,36 @@
+from typing import Any, List
+
+from data_profiling.config import Style
+from data_profiling.model.alerts import Alert
+from data_profiling.report.presentation.core.item_renderer import ItemRenderer
+
+
+class VariableInfo(ItemRenderer):
+    def __init__(
+        self,
+        anchor_id: str,
+        var_name: str,
+        var_type: str,
+        alerts: List[Alert],
+        description: str,
+        style: Style,
+        **kwargs
+    ):
+        super().__init__(
+            "variable_info",
+            {
+                "anchor_id": anchor_id,
+                "var_name": var_name,
+                "description": description,
+                "var_type": var_type,
+                "alerts": alerts,
+                "style": style,
+            },
+            **kwargs
+        )
+
+    def __repr__(self) -> str:
+        return "VariableInfo"
+
+    def render(self) -> Any:
+        raise NotImplementedError()

data_profiling/report/presentation/flavours/__init__.py

@@ -0,0 +1,9 @@
+from data_profiling.report.presentation.flavours.flavours import (
+    HTMLReport,
+    WidgetReport,
+)
+
+__all__ = [
+    "HTMLReport",
+    "WidgetReport",
+]

data_profiling/report/presentation/flavours/flavour_html.py

@@ -0,0 +1,64 @@
+"""
+    HTML flavour mapping
+"""
+from data_profiling.report.presentation.core import (
+    HTML,
+    Alerts,
+    Collapse,
+    Container,
+    CorrelationTable,
+    Dropdown,
+    Duplicate,
+    FrequencyTable,
+    FrequencyTableSmall,
+    Image,
+    Root,
+    Sample,
+    Scores,
+    Table,
+    ToggleButton,
+    Variable,
+    VariableInfo,
+)
+from data_profiling.report.presentation.flavours.flavours import register_flavour
+from data_profiling.report.presentation.flavours.html import (
+    HTMLHTML,
+    HTMLAlerts,
+    HTMLCollapse,
+    HTMLContainer,
+    HTMLCorrelationTable,
+    HTMLDropdown,
+    HTMLDuplicate,
+    HTMLFrequencyTable,
+    HTMLFrequencyTableSmall,
+    HTMLImage,
+    HTMLRoot,
+    HTMLSample,
+    HTMLScores,
+    HTMLTable,
+    HTMLToggleButton,
+    HTMLVariable,
+    HTMLVariableInfo,
+)
+
+html_mapping = {
+    Container: HTMLContainer,
+    Variable: HTMLVariable,
+    VariableInfo: HTMLVariableInfo,
+    Table: HTMLTable,
+    HTML: HTMLHTML,
+    Root: HTMLRoot,
+    Image: HTMLImage,
+    FrequencyTable: HTMLFrequencyTable,
+    FrequencyTableSmall: HTMLFrequencyTableSmall,
+    Alerts: HTMLAlerts,
+    Duplicate: HTMLDuplicate,
+    Dropdown: HTMLDropdown,
+    Sample: HTMLSample,
+    ToggleButton: HTMLToggleButton,
+    Collapse: HTMLCollapse,
+    CorrelationTable: HTMLCorrelationTable,
+    Scores: HTMLScores,
+}
+
+register_flavour("html", html_mapping)

data_profiling/report/presentation/flavours/flavour_widget.py

@@ -0,0 +1,61 @@
+"""
+    Flavour widget
+"""
+from data_profiling.report.presentation.core import (
+    HTML,
+    Alerts,
+    Collapse,
+    Container,
+    CorrelationTable,
+    Dropdown,
+    Duplicate,
+    FrequencyTable,
+    FrequencyTableSmall,
+    Image,
+    Root,
+    Sample,
+    Table,
+    ToggleButton,
+    Variable,
+    VariableInfo,
+)
+from data_profiling.report.presentation.flavours.flavours import register_flavour
+from data_profiling.report.presentation.flavours.widget import (
+    WidgetAlerts,
+    WidgetCollapse,
+    WidgetContainer,
+    WidgetCorrelationTable,
+    WidgetDropdown,
+    WidgetDuplicate,
+    WidgetFrequencyTable,
+    WidgetFrequencyTableSmall,
+    WidgetHTML,
+    WidgetImage,
+    WidgetRoot,
+    WidgetSample,
+    WidgetTable,
+    WidgetToggleButton,
+    WidgetVariable,
+    WidgetVariableInfo,
+)
+
+widget_mapping = {
+    Container: WidgetContainer,
+    Variable: WidgetVariable,
+    VariableInfo: WidgetVariableInfo,
+    Table: WidgetTable,
+    HTML: WidgetHTML,
+    Root: WidgetRoot,
+    Image: WidgetImage,
+    FrequencyTable: WidgetFrequencyTable,
+    FrequencyTableSmall: WidgetFrequencyTableSmall,
+    Alerts: WidgetAlerts,
+    Duplicate: WidgetDuplicate,
+    Dropdown: WidgetDropdown,
+    Sample: WidgetSample,
+    ToggleButton: WidgetToggleButton,
+    Collapse: WidgetCollapse,
+    CorrelationTable: WidgetCorrelationTable,
+}
+
+register_flavour("widget", widget_mapping)

data_profiling/report/presentation/flavours/flavours.py

@@ -0,0 +1,43 @@
+"""
+    Flavours registry information
+"""
+from data_profiling.report.presentation.core import Root
+from data_profiling.report.presentation.core.renderable import Renderable
+
+_FLAVOUR_REGISTRY: dict = {}
+
+
+def register_flavour(name: str, mapping: dict) -> None:
+    _FLAVOUR_REGISTRY[name] = mapping
+
+
+def get_flavour_mapping(name: str) -> dict:
+    if name not in _FLAVOUR_REGISTRY:
+        raise ValueError(f"Flavour '{name}' is not registered.")
+    return _FLAVOUR_REGISTRY[name]
+
+
+def apply_renderable_mapping(
+    mapping: dict,
+    structure: Renderable,
+    flavour_func,  # noqa: ANN001
+) -> None:
+    mapping[type(structure)].convert_to_class(structure, flavour_func)
+
+
+def HTMLReport(structure: Root) -> Root:
+    from data_profiling.report.presentation.flavours import flavour_html  # noqa: F401
+
+    mapping = get_flavour_mapping("html")
+    apply_renderable_mapping(mapping, structure, flavour_func=HTMLReport)
+    return structure
+
+
+def WidgetReport(structure: Root) -> Root:
+    from data_profiling.report.presentation.flavours import (  # noqa: F401
+        flavour_widget,
+    )
+
+    mapping = get_flavour_mapping("widget")
+    apply_renderable_mapping(mapping, structure, flavour_func=WidgetReport)
+    return structure

data_profiling/report/presentation/flavours/html/__init__.py

@@ -0,0 +1,47 @@
+from data_profiling.report.presentation.flavours.html.alerts import HTMLAlerts
+from data_profiling.report.presentation.flavours.html.collapse import HTMLCollapse
+from data_profiling.report.presentation.flavours.html.container import HTMLContainer
+from data_profiling.report.presentation.flavours.html.correlation_table import (
+    HTMLCorrelationTable,
+)
+from data_profiling.report.presentation.flavours.html.dropdown import HTMLDropdown
+from data_profiling.report.presentation.flavours.html.duplicate import HTMLDuplicate
+from data_profiling.report.presentation.flavours.html.frequency_table import (
+    HTMLFrequencyTable,
+)
+from data_profiling.report.presentation.flavours.html.frequency_table_small import (
+    HTMLFrequencyTableSmall,
+)
+from data_profiling.report.presentation.flavours.html.html import HTMLHTML
+from data_profiling.report.presentation.flavours.html.image import HTMLImage
+from data_profiling.report.presentation.flavours.html.root import HTMLRoot
+from data_profiling.report.presentation.flavours.html.sample import HTMLSample
+from data_profiling.report.presentation.flavours.html.scores import HTMLScores
+from data_profiling.report.presentation.flavours.html.table import HTMLTable
+from data_profiling.report.presentation.flavours.html.toggle_button import (
+    HTMLToggleButton,
+)
+from data_profiling.report.presentation.flavours.html.variable import HTMLVariable
+from data_profiling.report.presentation.flavours.html.variable_info import (
+    HTMLVariableInfo,
+)
+
+__all__ = [
+    "HTMLCollapse",
+    "HTMLContainer",
+    "HTMLDuplicate",
+    "HTMLDropdown",
+    "HTMLFrequencyTable",
+    "HTMLFrequencyTableSmall",
+    "HTMLHTML",
+    "HTMLImage",
+    "HTMLRoot",
+    "HTMLSample",
+    "HTMLTable",
+    "HTMLToggleButton",
+    "HTMLVariable",
+    "HTMLVariableInfo",
+    "HTMLAlerts",
+    "HTMLCorrelationTable",
+    "HTMLScores",
+]

data_profiling/report/presentation/flavours/html/alerts.py

@@ -0,0 +1,10 @@
+from data_profiling.report.presentation.core.alerts import Alerts
+from data_profiling.report.presentation.flavours.html import templates
+from data_profiling.utils.styles import get_alert_styles
+
+
+class HTMLAlerts(Alerts):
+    def render(self) -> str:
+        styles = get_alert_styles()
+
+        return templates.template("alerts.html").render(**self.content, styles=styles)

data_profiling/report/presentation/flavours/html/collapse.py

@@ -0,0 +1,7 @@
+from data_profiling.report.presentation.core import Collapse
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLCollapse(Collapse):
+    def render(self) -> str:
+        return templates.template("collapse.html").render(**self.content)

data_profiling/report/presentation/flavours/html/container.py

@@ -0,0 +1,58 @@
+"""
+    Container class definition
+"""
+from data_profiling.report.presentation.core.container import Container
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLContainer(Container):
+    def render(self) -> str:
+        if self.sequence_type in ["list", "accordion"]:
+            return templates.template("sequence/list.html").render(
+                anchor_id=self.content["anchor_id"], items=self.content["items"]
+            )
+        elif self.sequence_type == "named_list":
+            return templates.template("sequence/named_list.html").render(
+                anchor_id=self.content["anchor_id"], items=self.content["items"]
+            )
+        elif self.sequence_type == "overview_tabs":
+            return templates.template("sequence/overview_tabs.html").render(
+                tabs=self.content["items"],
+                anchor_id=self.content["anchor_id"],
+                nested=self.content["nested"],
+                oss=self.oss,
+            )
+        elif self.sequence_type == "tabs":
+            return templates.template("sequence/tabs.html").render(
+                tabs=self.content["items"],
+                anchor_id=self.content["anchor_id"],
+                nested=self.content["nested"],
+            )
+        elif self.sequence_type == "select":
+            return templates.template("sequence/select.html").render(
+                tabs=self.content["items"],
+                anchor_id=self.content["anchor_id"],
+                nested=self.content["nested"],
+            )
+        elif self.sequence_type == "sections":
+            return templates.template("sequence/sections.html").render(
+                sections=self.content["items"],
+                full_width=self.content["full_width"],
+            )
+        elif self.sequence_type == "grid":
+            return templates.template("sequence/grid.html").render(
+                items=self.content["items"]
+            )
+        elif self.sequence_type == "batch_grid":
+            return templates.template("sequence/batch_grid.html").render(
+                items=self.content["items"],
+                batch_size=self.content["batch_size"],
+                titles=self.content.get("titles", True),
+                subtitles=self.content.get("subtitles", False),
+            )
+        elif self.sequence_type == "scores":
+            return templates.template("sequence/scores.html").render(
+                anchor_id=self.content["anchor_id"], items=self.content["items"]
+            )
+        else:
+            raise ValueError("Template not understood", self.sequence_type)

data_profiling/report/presentation/flavours/html/correlation_table.py

@@ -0,0 +1,13 @@
+from data_profiling.report.presentation.core.correlation_table import CorrelationTable
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLCorrelationTable(CorrelationTable):
+    def render(self) -> str:
+        correlation_matrix_html = self.content["correlation_matrix"].to_html(
+            classes="correlation-table table table-striped",
+            float_format="{:.3f}".format,
+        )
+        return templates.template("correlation_table.html").render(
+            **self.content, correlation_matrix_html=correlation_matrix_html
+        )

data_profiling/report/presentation/flavours/html/dropdown.py

@@ -0,0 +1,7 @@
+from data_profiling.report.presentation.core import Dropdown
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLDropdown(Dropdown):
+    def render(self) -> str:
+        return templates.template("dropdown.html").render(**self.content)

data_profiling/report/presentation/flavours/html/duplicate.py

@@ -0,0 +1,24 @@
+import pandas as pd
+
+from data_profiling.report.presentation.core.duplicate import Duplicate
+from data_profiling.report.presentation.flavours.html import templates
+
+
+def to_html(df: pd.DataFrame) -> str:
+    html = df.to_html(
+        classes="duplicate table table-striped",
+    )
+    if df.empty:
+        html = html.replace(
+            "<tbody>",
+            f"<tbody><tr><td colspan={len(df.columns) + 1}>Dataset does not contain duplicate rows.</td></tr>",
+        )
+    return html
+
+
+class HTMLDuplicate(Duplicate):
+    def render(self) -> str:
+        duplicate_html = to_html(self.content["duplicate"])
+        return templates.template("duplicate.html").render(
+            **self.content, duplicate_html=duplicate_html
+        )

data_profiling/report/presentation/flavours/html/frequency_table.py

@@ -0,0 +1,20 @@
+from data_profiling.report.presentation.core import FrequencyTable
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLFrequencyTable(FrequencyTable):
+    def render(self) -> str:
+        if isinstance(self.content["rows"][0], list):
+            html = ""
+
+            kwargs = self.content.copy()
+            del kwargs["rows"]
+            for idx, rows in enumerate(self.content["rows"]):
+                html += templates.template("frequency_table.html").render(
+                    rows=rows, idx=idx, **kwargs
+                )
+            return html
+        else:
+            return templates.template("frequency_table.html").render(
+                **self.content, idx=0
+            )

data_profiling/report/presentation/flavours/html/frequency_table_small.py

@@ -0,0 +1,15 @@
+from data_profiling.report.presentation.core import FrequencyTableSmall
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLFrequencyTableSmall(FrequencyTableSmall):
+    def render(self) -> str:
+        html = ""
+        kwargs = self.content.copy()
+        del kwargs["rows"]
+
+        for idx, rows in enumerate(self.content["rows"]):
+            html += templates.template("frequency_table_small.html").render(
+                rows=rows, idx=idx, **kwargs
+            )
+        return html

data_profiling/report/presentation/flavours/html/html.py

@@ -0,0 +1,6 @@
+from data_profiling.report.presentation.core import HTML
+
+
+class HTMLHTML(HTML):
+    def render(self) -> str:
+        return self.content["html"]

data_profiling/report/presentation/flavours/html/image.py

@@ -0,0 +1,7 @@
+from data_profiling.report.presentation.core import Image
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLImage(Image):
+    def render(self) -> str:
+        return templates.template("diagram.html").render(**self.content)

data_profiling/report/presentation/flavours/html/root.py

@@ -0,0 +1,14 @@
+from data_profiling.report.presentation.core.root import Root
+from data_profiling.report.presentation.flavours.html import templates
+
+
+class HTMLRoot(Root):
+    def render(self, **kwargs) -> str:
+        nav_items = [
+            (section.name, section.anchor_id)
+            for section in self.content["body"].content["items"]
+        ]
+
+        return templates.template("report.html").render(
+            **self.content, nav_items=nav_items, **kwargs
+        )