validmind 2.1.1__py3-none-any.whl → 2.2.4__py3-none-any.whl

validmind/template.py

@@ -2,20 +2,15 @@
 # See the LICENSE file in the root of this repository for details.
 # SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
 
-from pprint import pformat
-
-import mistune
-from IPython.display import display
 from ipywidgets import HTML, Accordion, VBox
 
 from .html_templates.content_blocks import (
     failed_content_block_html,
     non_test_content_block_html,
-    test_content_block_html,
 )
 from .logging import get_logger
 from .tests import LoadTestError, describe_test
-from .utils import is_notebook
+from .utils import display, is_notebook
 from .vm_models import TestSuite
 
 logger = get_logger(__name__)
@@ -26,6 +21,7 @@ CONTENT_TYPE_MAP = {
     "metadata_text": "Metadata Text",
     "dynamic": "Dynamic Content",
     "text": "Text",
+    "risk_assessment": "Risk Assessment",
 }
 
 
@@ -66,29 +62,12 @@ def _create_content_widget(content):
         )
 
     try:
-        test_deets = describe_test(test_id=content["content_id"], raw=True)
+        test_html = describe_test(test_id=content["content_id"], show=False)
     except LoadTestError:
         return HTML(failed_content_block_html.format(test_id=content["content_id"]))
 
     return Accordion(
-        children=[
-            HTML(
-                test_content_block_html.format(
-                    title=test_deets["Name"],
-                    description=mistune.html(test_deets["Description"]),
-                    required_inputs=", ".join(
-                        test_deets["Required Inputs"] or ["None"]
-                    ),
-                    params_table="\n".join(
-                        [
-                            f"<tr><td>{param}</td><td>{pformat(value, indent=4)}</td></tr>"
-                            for param, value in test_deets["Params"].items()
-                        ]
-                    ),
-                    table_display="table" if test_deets["Params"] else "none",
-                )
-            )
-        ],
+        children=[HTML(test_html)],
         titles=[f"{content_type} Block: '{content['content_id']}'"],
     )
 
@@ -117,7 +96,10 @@ def _create_sub_section_widget(sub_sections, section_number):
                 contents_widget,
             )
         else:
-            accordion.children = (*accordion.children, HTML("<p>Empty Section</p>"))
+            accordion.children = (
+                *accordion.children,
+                HTML("<p>Empty Section</p>"),
+            )
 
         accordion.set_title(
             i, f"{section_number}.{i + 1}. {section['title']} ('{section['id']}')"

validmind/tests/__init__.py

@@ -6,22 +6,29 @@
 
 import importlib
 import inspect
+import json
 import sys
 from pathlib import Path
 from pprint import pformat
 from typing import Dict
+from uuid import uuid4
 
-import mistune
 import pandas as pd
-from IPython.display import display
-from ipywidgets import HTML
+from ipywidgets import HTML, Accordion
 
 from ..errors import LoadTestError
 from ..html_templates.content_blocks import test_content_block_html
 from ..logging import get_logger
 from ..unit_metrics import run_metric
 from ..unit_metrics.composite import load_composite_metric
-from ..utils import format_dataframe, fuzzy_match, test_id_to_name
+from ..utils import (
+    NumpyEncoder,
+    display,
+    format_dataframe,
+    fuzzy_match,
+    md_to_html,
+    test_id_to_name,
+)
 from ..vm_models import TestContext, TestInput
 from .decorator import metric, tags, tasks
 from .test_providers import LocalTestProvider, TestProvider
@@ -75,10 +82,12 @@ def _pretty_list_tests(tests, truncate=True):
 
     table = [
         {
-            "Test Type": __test_classes[test_id].test_type,
+            "ID": test_id,
             "Name": test_id_to_name(test_id),
+            "Test Type": __test_classes[test_id].test_type,
             "Description": _test_description(__test_classes[test_id], truncate),
-            "ID": test_id,
+            "Required Inputs": __test_classes[test_id].required_inputs,
+            "Params": __test_classes[test_id].default_params or {},
         }
         for test_id in tests
     ]
@@ -339,7 +348,7 @@ def load_test(test_id: str, reload=False):
     return test
 
 
-def describe_test(test_id: str = None, raw: bool = False):
+def describe_test(test_id: str = None, raw: bool = False, show: bool = True):
     """Get or show details about the test
 
     This function can be used to see test details including the test name, description,
@@ -365,20 +374,34 @@ def describe_test(test_id: str = None, raw: bool = False):
     if raw:
         return details
 
+    html = test_content_block_html.format(
+        test_id=test_id,
+        uuid=str(uuid4()),
+        title=f'{details["Name"]}',
+        description=md_to_html(details["Description"].strip()),
+        required_inputs=", ".join(details["Required Inputs"] or ["None"]),
+        params_table="\n".join(
+            [
+                f"<tr><td>{param}</td><td>{pformat(value, indent=4)}</td></tr>"
+                for param, value in details["Params"].items()
+            ]
+        ),
+        table_display="table" if details["Params"] else "none",
+        example_inputs=json.dumps(
+            {name: f"my_vm_{name}" for name in (details["Required Inputs"] or [])},
+            indent=4,
+        ),
+        example_params=json.dumps(details["Params"] or {}, indent=4, cls=NumpyEncoder),
+        instructions_display="block" if show else "none",
+    )
+
+    if not show:
+        return html
+
     display(
-        HTML(
-            test_content_block_html.format(
-                title=f'{details["Name"]}',
-                description=mistune.html(details["Description"].strip()),
-                required_inputs=", ".join(details["Required Inputs"] or ["None"]),
-                params_table="\n".join(
-                    [
-                        f"<tr><td>{param}</td><td>{pformat(value, indent=4)}</td></tr>"
-                        for param, value in details["Params"].items()
-                    ]
-                ),
-                table_display="table" if details["Params"] else "none",
-            )
+        Accordion(
+            children=[HTML(html)],
+            titles=[f"Test Description: {details['Name']} ('{test_id}')"],
         )
     )
 

validmind/tests/data_validation/ANOVAOneWayTable.py

@@ -74,7 +74,7 @@ class ANOVAOneWayTable(Metric):
 
         # Select all numerical features if none are specified
         if features is None:
-            features = self.inputs.dataset.get_numeric_features_columns()
+            features = self.inputs.dataset.feature_columns_numeric
 
         anova_results = self.anova_numerical_features(features, p_threshold)
 

validmind/tests/data_validation/ChiSquaredFeaturesTable.py

@@ -72,7 +72,7 @@ class ChiSquaredFeaturesTable(Metric):
 
         # Ensure cat_features is provided
         if not cat_features:
-            cat_features = self.inputs.dataset.get_categorical_features_columns()
+            cat_features = self.inputs.dataset.feature_columns_categorical
 
         df = self.inputs.dataset.df
 

validmind/tests/data_validation/DescriptiveStatistics.py

@@ -116,10 +116,8 @@ class DescriptiveStatistics(Metric):
 
     def run(self):
         feature_columns = self.inputs.dataset.feature_columns
-        numerical_feature_columns = self.inputs.dataset.get_numeric_features_columns()
-        categorical_feature_columns = (
-            self.inputs.dataset.get_categorical_features_columns()
-        )
+        numerical_feature_columns = self.inputs.dataset.feature_columns_numeric
+        categorical_feature_columns = self.inputs.dataset.feature_columns_categorical
 
         df = self.inputs.dataset.df[feature_columns]
 

validmind/tests/data_validation/Duplicates.py

@@ -84,7 +84,7 @@ class Duplicates(ThresholdTest):
         if self.inputs.dataset.text_column:
             columns = self.inputs.dataset.text_column
         else:
-            columns = self.inputs.dataset.get_features_columns()
+            columns = self.inputs.dataset.feature_columns
 
         df = self.inputs.dataset.df[columns]
         # Find duplicate rows

validmind/tests/data_validation/IsolationForestOutliers.py

@@ -64,13 +64,13 @@ class IsolationForestOutliers(Metric):
 
     def run(self):
         if self.params["features_columns"] is None:
-            features_list = self.inputs.dataset.get_features_columns()
+            features_list = self.inputs.dataset.feature_columns
         else:
             features_list = self.params["features_columns"]
 
         # Check if all elements from features_list are present in the feature columns
         all_present = all(
-            elem in self.inputs.dataset.get_features_columns() for elem in features_list
+            elem in self.inputs.dataset.feature_columns for elem in features_list
         )
         if not all_present:
             raise ValueError(

validmind/tests/data_validation/LaggedCorrelationHeatmap.py

@@ -115,7 +115,7 @@ class LaggedCorrelationHeatmap(Metric):
         else:
             target_col = self.inputs.dataset.target_column
 
-        independent_vars = list(self.inputs.dataset.get_features_columns())
+        independent_vars = list(self.inputs.dataset.feature_columns)
         num_lags = self.params.get("num_lags", 10)
 
         if isinstance(target_col, list) and len(target_col) == 1:

validmind/tests/data_validation/TargetRateBarPlots.py

@@ -57,7 +57,7 @@ class TargetRateBarPlots(Metric):
 
         # Use all categorical features if columns is not specified, else use selected columns
         if columns is None:
-            features = self.inputs.dataset.get_categorical_features_columns()
+            features = self.inputs.dataset.feature_columns_categorical
         else:
             features = columns
 

validmind/tests/data_validation/nlp/LanguageDetection.py

@@ -0,0 +1,59 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+"""
+Metrics functions for any Pandas-compatible datasets
+"""
+
+
+import plotly.express as px
+from langdetect import LangDetectException, detect
+
+from validmind import tags, tasks
+
+
+@tags("nlp", "text_data", "visualization")
+@tasks("text_classification", "text_summarization")
+def LanguageDetection(dataset):
+    """
+    Detects the language of each text entry in a dataset and visualizes the distribution of languages
+    as a histogram.
+
+    This method checks for a specified text column in the dataset's dataframe, uses a language detection
+    library to determine the language of each text entry, and returns a histogram plot of the language
+    distribution.
+
+    Args:
+        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
+            and a `text_column` attribute indicating the name of the column containing text. If the
+            `text_column` attribute is not set, a ValueError is raised.
+
+    Returns:
+        plotly.graph_objs._figure.Figure: A Plotly histogram plot showing the distribution of detected
+        languages across the dataset's text entries.
+
+    Raises:
+        ValueError: If the `text_column` is not specified in the dataset object.
+    """
+    # check text column
+    if not dataset.text_column:
+        raise ValueError("Please set text_column name in the Validmind Dataset object")
+
+    # Function to detect language
+    def detect_language(text):
+        try:
+            return detect(text)
+        except LangDetectException:
+            return "Unknown"  # Return 'Unknown' if language detection fails
+
+    # Applying the language detection function to each text entry
+    languages = dataset.df[dataset.text_column].apply(detect_language)
+    fig = px.histogram(
+        languages,
+        x=languages,
+        title="Language Distribution",
+        labels={"x": "Language Codes"},
+    )
+
+    return fig

validmind/tests/data_validation/nlp/PolarityAndSubjectivity.py

@@ -0,0 +1,48 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+
+import pandas as pd
+import plotly.express as px
+from textblob import TextBlob
+
+from validmind import tags, tasks
+
+
+@tags("data_validation")
+@tasks("nlp")
+def PolarityAndSubjectivity(dataset):
+    """
+    Analyzes the polarity and subjectivity of text data within a dataset.
+
+    This method processes a dataset containing textual data to compute the polarity and
+    subjectivity scores using TextBlob, and returns a Plotly scatter plot visualizing
+    these scores.
+
+    Args:
+        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
+            and a `text_column` attribute indicating the name of the column containing text.
+
+    Returns:
+        plotly.graph_objs._figure.Figure: A Plotly scatter plot of polarity vs subjectivity.
+    """
+    # Function to calculate sentiment and subjectivity
+    def analyze_sentiment(text):
+        analysis = TextBlob(text)
+        return analysis.sentiment.polarity, analysis.sentiment.subjectivity
+
+    data = pd.DataFrame()
+    # Apply the function to each row
+    data[["polarity", "subjectivity"]] = dataset.df[dataset.text_column].apply(
+        lambda x: pd.Series(analyze_sentiment(x))
+    )
+
+    # Create a Plotly scatter plot
+    fig = px.scatter(
+        data, x="polarity", y="subjectivity", title="Polarity vs Subjectivity"
+    )
+    fig.update_traces(textposition="top center")
+    fig.update_layout(xaxis_title="Polarity", yaxis_title="Subjectivity")
+
+    return fig

validmind/tests/data_validation/nlp/Punctuations.py

@@ -72,25 +72,24 @@ class Punctuations(Metric):
         text_column = self.inputs.dataset.text_column
         corpus = create_corpus(self.inputs.dataset.df, text_column=text_column)
 
-        dic = defaultdict(int)
         special = string.punctuation
+        dic = defaultdict(int, {key: 0 for key in special})
         for i in corpus:
             if i in special:
                 dic[i] += 1
-
+        figures = []
+        # if dic:
         fig = plt.figure()
         x, y = zip(*dic.items())
         plt.bar(x, y, color="#17C37B")
-
+        figures.append(
+            Figure(
+                for_object=self,
+                key=self.key,
+                figure=fig,
+            )
+        )
         # Do this if you want to prevent the figure from being displayed
         plt.close("all")
 
-        return self.cache_results(
-            figures=[
-                Figure(
-                    for_object=self,
-                    key=self.key,
-                    figure=fig,
-                )
-            ]
-        )
+        return self.cache_results(figures=figures)

validmind/tests/data_validation/nlp/Sentiment.py

@@ -0,0 +1,57 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+
+import matplotlib.pyplot as plt
+import nltk
+import seaborn as sns
+from nltk.sentiment import SentimentIntensityAnalyzer
+
+from validmind import tags, tasks
+
+
+@tags("data_validation")
+@tasks("nlp")
+def Sentiment(dataset):
+    """
+    Analyzes the sentiment of text data within a dataset using the VADER sentiment analysis tool.
+
+    This method initializes the VADER SentimentIntensityAnalyzer and applies it to each text entry
+    in the specified column of the dataset's dataframe. It returns a KDE plot visualizing the distribution
+    of sentiment scores across the dataset.
+
+    Args:
+        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
+            and a `text_column` attribute indicating the name of the column containing text.
+
+    Returns:
+        matplotlib.figure.Figure: A KDE plot visualizing the distribution of sentiment scores.
+    """
+    nltk.download("vader_lexicon", quiet=True)
+    # Initialize VADER
+    sia = SentimentIntensityAnalyzer()
+
+    # Function to get VADER sentiment scores
+    def get_vader_sentiment(text):
+        sentiment_score = sia.polarity_scores(text)
+        return sentiment_score["compound"]
+
+    # Apply the function to each row
+    vader_sentiment = dataset.df[dataset.text_column].apply(get_vader_sentiment)
+
+    fig = plt.figure()
+    ax = sns.kdeplot(
+        x=vader_sentiment,
+        fill=True,
+        common_norm=False,
+        palette="crest",
+        alpha=0.5,
+        linewidth=0,
+    )
+    ax.set_title(f"Sentiment score of {dataset.text_column} ")
+    ax.set_xlabel("Sentiment score")
+
+    plt.close("all")
+
+    return fig

validmind/tests/data_validation/nlp/Toxicity.py

@@ -0,0 +1,45 @@
+# Copyright © 2023-2024 ValidMind Inc. All rights reserved.
+# See the LICENSE file in the root of this repository for details.
+# SPDX-License-Identifier: AGPL-3.0 AND ValidMind Commercial
+
+import evaluate
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from validmind import tags, tasks
+
+
+@tags("data_validation")
+@tasks("nlp")
+def Toxicity(dataset):
+    """
+    Analyzes the toxicity of text data within a dataset using a pre-trained toxicity model.
+
+    This method loads a toxicity evaluation model and applies it to each text entry
+    in the specified column of the dataset's dataframe. It returns a KDE plot visualizing the distribution
+    of toxicity scores across the dataset.
+
+    Args:
+        dataset (Dataset): A dataset object which must have a `df` attribute (a pandas DataFrame)
+            and a `text_column` attribute indicating the name of the column containing text.
+
+    Returns:
+        matplotlib.figure.Figure: A KDE plot visualizing the distribution of toxicity scores.
+    """
+    toxicity = evaluate.load("toxicity")
+    input_text = dataset.df[dataset.text_column]
+    toxicity_scores = toxicity.compute(predictions=list(input_text.values))["toxicity"]
+
+    fig = plt.figure()
+    ax = sns.kdeplot(
+        x=toxicity_scores,
+        fill=True,
+        common_norm=False,
+        palette="crest",
+        alpha=0.5,
+        linewidth=0,
+    )
+    ax.set_title(f"Toxicity score of {dataset.text_column} ")
+    ax.set_xlabel("Toxicity score")
+    plt.close("all")
+    return fig

validmind/tests/decorator.py

@@ -15,6 +15,7 @@ import pandas as pd
 
 from validmind.errors import MissingRequiredTestInputError
 from validmind.logging import get_logger
+from validmind.utils import get_description_metadata
 from validmind.vm_models import (
     Metric,
     MetricResult,
@@ -113,20 +114,24 @@ def _build_result(results, test_id, description, output_template, inputs):  # no
     else:
         process_item(results)
 
+    result_summary = ResultSummary(results=tables)
+
     return MetricResultWrapper(
         result_id=test_id,
         metric=MetricResult(
             key=test_id,
             ref_id=ref_id,
             value="Empty",
-            summary=ResultSummary(results=tables),
+            summary=result_summary,
         ),
         figures=figures,
         result_metadata=[
-            {
-                "content_id": f"metric_description:{test_id}",
-                "text": description,
-            }
+            get_description_metadata(
+                test_id=test_id,
+                default_description=description,
+                summary=result_summary.serialize(),
+                figures=figures,
+            )
         ],
         inputs=inputs,
         output_template=output_template,
@@ -153,7 +158,7 @@ def _get_run_method(func, inputs, params):
             test_id=self.test_id,
             description=inspect.getdoc(self),
             output_template=self.output_template,
-            inputs=list(inputs.keys()),
+            inputs=self.get_accessed_inputs(),
         )
 
         return self.result
@@ -264,7 +269,7 @@ def metric(func_or_id):
             {
                 "run": _get_run_method(func, inputs, params),
                 "required_inputs": list(inputs.keys()),
-                "default_parameters": params,
+                "default_params": {k: v["default"] for k, v in params.items()},
                 "__doc__": description,
                 "metadata": {
                     "task_types": tasks,