ibm-watsonx-gov 1.3.3__cp313-cp313-macosx_11_0_arm64.whl

ibm_watsonx_gov/metrics/reciprocal_rank/reciprocal_rank_metric.py

@@ -0,0 +1,162 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from typing import Annotated, Any, Literal
+
+import pandas as pd
+from pydantic import Field, TypeAdapter, field_validator
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration, GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import (AggregateMetricResult,
+                                                        RecordMetricResult)
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.metrics.context_relevance.context_relevance_metric import (
+    CONTEXT_RELEVANCE, ContextRelevanceMetric, ContextRelevanceResult)
+
+RECIPROCAL_RANK = "reciprocal_rank"
+RECIPROCAL_RANK_DISPLAY_NAME = "Reciprocal Rank"
+
+
+class ReciprocalRankResult(RecordMetricResult):
+    name: str = RECIPROCAL_RANK
+    display_name: str = RECIPROCAL_RANK_DISPLAY_NAME
+    group: MetricGroup = MetricGroup.RETRIEVAL_QUALITY
+
+
+class ReciprocalRankMetric(GenAIMetric):
+    """
+    Defines the Reciprocal Rank metric class.
+
+    The Reciprocal Rank metric measures the reciprocal rank of the first relevant context.
+    The Context Relevance metric is computed as a pre requisite to compute this metric.
+
+    Examples:
+        1. Create Reciprocal Rank metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = ReciprocalRankMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": "..."},
+                                                    metrics=[metric])
+                # A list of contexts can also be passed as shown below
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": ["...", "..."]},
+                                                    metrics=[metric])
+
+        2. Create Reciprocal Rank metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="lower_limit", value=0.5)
+                metric = ReciprocalRankMetric(method=method, threshold=threshold)
+
+        3. Create Reciprocal Rank metric with llm_as_judge method.
+            .. code-block:: python
+
+                # Define LLM Judge using watsonx.ai
+                # To use other frameworks and models as llm_judge, see :module:`ibm_watsonx_gov.entities.foundation_model`
+                llm_judge = LLMJudge(model=WxAIFoundationModel(
+                                            model_id="ibm/granite-3-3-8b-instruct",
+                                            project_id="<PROJECT_ID>"
+                                    ))
+                cr_metric = ContextRelevanceMetric(llm_judge=llm_judge)
+                ap_metric = ReciprocalRankMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": ["...", "..."]},
+                                                    metrics=[cr_metric, ap_metric])
+    """
+    name: Annotated[Literal["reciprocal_rank"],
+                    Field(title="Name",
+                          description="The reciprocal rank metric name.",
+                          default=RECIPROCAL_RANK, frozen=True)]
+    display_name: Annotated[Literal["Reciprocal Rank"],
+                            Field(title="Display Name",
+                                  description="The reciprocal rank metric display name.",
+                                  default=RECIPROCAL_RANK_DISPLAY_NAME, frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=[TaskType.RAG])]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="lower_limit", value=0.7)])]
+    metric_dependencies: Annotated[list[GenAIMetric],
+                                   Field(title="Metric dependencies",
+                                         description="The list of metric dependencies",
+                                         default=[ContextRelevanceMetric()])]
+    group: Annotated[MetricGroup,
+                     Field(title="Group",
+                           description="The metric group.",
+                           default=MetricGroup.RETRIEVAL_QUALITY, frozen=True)]
+
+    @field_validator("metric_dependencies", mode="before")
+    @classmethod
+    def metric_dependencies_validator(cls, value: Any):
+        if value:
+            value = [TypeAdapter(Annotated[ContextRelevanceMetric, Field(
+                discriminator="name")]).validate_python(
+                m) for m in value]
+        return value
+
+    def evaluate(
+            self,
+            data: pd.DataFrame,
+            configuration: GenAIConfiguration | AgenticAIConfiguration,
+            metrics_result: list[AggregateMetricResult],
+            **kwargs,
+    ) -> AggregateMetricResult:
+        record_level_metrics = []
+        scores = []
+
+        context_relevance_result: list[ContextRelevanceResult] = next(
+            (metric_result.record_level_metrics for metric_result in metrics_result if metric_result.name == CONTEXT_RELEVANCE), None)
+
+        if context_relevance_result is None:
+            raise Exception(
+                f"Failed to evaluate {self.name} metric. Missing context relevance metric result")
+
+        for relevance_result in context_relevance_result:
+            score = self.__compute(
+                relevance_scores=relevance_result.additional_info.get(
+                    "contexts_values", []),
+                threshold=self.thresholds[0].value,
+            )
+            scores.append(score)
+            record_level_metrics.append(
+                ReciprocalRankResult(
+                    method="",
+                    provider="",
+                    record_id=relevance_result.record_id,
+                    value=score,
+                    thresholds=self.thresholds,
+                )
+            )
+
+        mean = sum(scores) / len(scores)
+        aggregate_metric_score = AggregateMetricResult(
+            name=self.name,
+            display_name=self.display_name,
+            method="",
+            provider="",
+            group=self.group,
+            min=min(scores),
+            max=max(scores),
+            mean=mean,
+            value=mean,
+            total_records=len(record_level_metrics),
+            record_level_metrics=record_level_metrics,
+            thresholds=self.thresholds,
+        )
+
+        return aggregate_metric_score
+
+    def __compute(self, relevance_scores: list[float], threshold: float) -> float:
+        for i, score in enumerate(relevance_scores, start=1):
+            if score >= threshold:
+                return 1 / i
+        return 0

ibm_watsonx_gov/metrics/regex_detection/regex_detection_decorator.py

@@ -0,0 +1,58 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.regex_detection.regex_detection_metric import \
+    RegexDetectionMetric
+
+
+class RegexDetectionDecorator(BaseMetricDecorator):
+
+    def evaluate_regex(self,
+                       func: Optional[Callable] = None,
+                       *,
+                       configuration: Optional[AgenticAIConfiguration] = None,
+                       metrics: list[GenAIMetric]
+                       ) -> dict:
+        """
+        An evaluation decorator for computing regex detection on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_regex, configuration=configuration, metrics=metrics)
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(RegexDetectionMetric,))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=[])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating regex detection on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/regex_detection/regex_detection_metric.py

@@ -0,0 +1,106 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from typing import Annotated, Literal
+
+import pandas as pd
+from pydantic import Field
+
+from ibm_watsonx_gov.config.gen_ai_configuration import GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import AggregateMetricResult
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.providers.detectors_provider import DetectorsProvider
+from ibm_watsonx_gov.utils.async_util import run_in_event_loop
+from ibm_watsonx_gov.utils.validation_util import validate_input
+
+REGEX = "regex"
+
+
+class RegexDetectionMetric(GenAIMetric):
+    """
+    Defines the Regex Detection metric class.
+
+    The Regex detection metric detects specific regex pattern(s) when they are mentioned explicitly in natural language.
+
+    Examples:
+        1. Create regex detection metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = RegexDetectionMetric(case_sensitive=True, regex_patterns=["..."])
+                result = MetricsEvaluator().evaluate(data={"input_text": "..."}, metrics=[metric])
+
+        2. Create regex detection metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="upper_limit", value=0)
+                metric = RegexDetectionMetric(threshold=threshold, regex_patterns=["..."])
+    """
+    name: Annotated[Literal["regex_detection"],
+                    Field(title="Name",
+                          description="The regex detectionmetric name.",
+                          default="regex_detection", frozen=True)]
+    display_name: Annotated[Literal["Regex Detection"],
+                            Field(title="Display Name",
+                                  description="The regex detection metric display name.",
+                                  default="Regex Detection", frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=TaskType.values(), frozen=True)]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="upper_limit", value=0)])]
+    # group: Annotated[MetricGroup,
+    #                  Field(title="Group",
+    #                        description="The metric group.",
+    #                        default=MetricGroup.CONTENT_SAFETY, frozen=True)]
+
+    regex_patterns: Annotated[list[str], Field(title="Regex Patterns",
+                                               default=None,
+                                               description=f"List of regex patterns to match against the input text.")]
+
+    async def evaluate_async(
+            self,
+            data: pd.DataFrame,
+            configuration: GenAIConfiguration,
+            **kwargs
+    ) -> list[AggregateMetricResult]:
+        if not self.regex_patterns:
+            raise AssertionError(
+                f"The regex_patterns field is required, but was missing from the input.")
+
+        validate_input(data.columns.to_list(), configuration)
+        kwargs["detector_params"] = {"regex_patterns": self.regex_patterns}
+
+        provider = DetectorsProvider(configuration=configuration,
+                                     metric_name=REGEX,
+                                     metric_display_name=self.display_name,
+                                     metric_method=self.method,
+                                     metric_group=MetricGroup.CONTENT_SAFETY,
+                                     thresholds=self.thresholds,
+                                     **kwargs)
+        aggregated_metric_result = await provider.evaluate_async(data=data)
+        return aggregated_metric_result
+
+    def evaluate(
+        self,
+        data: pd.DataFrame | dict,
+        configuration: GenAIConfiguration,
+        **kwargs,
+    ):
+        # If ran in sync mode, block until it is done
+        return run_in_event_loop(
+            self.evaluate_async,
+            data=data,
+            configuration=configuration,
+            **kwargs,
+        )

ibm_watsonx_gov/metrics/retrieval_precision/retrieval_precision_decorator.py

@@ -0,0 +1,62 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.context_relevance.context_relevance_metric import \
+    ContextRelevanceMetric
+from ibm_watsonx_gov.metrics.retrieval_precision.retrieval_precision_metric import \
+    RetrievalPrecisionMetric
+
+
+class RetrievalPrecisionDecorator(BaseMetricDecorator):
+    def evaluate_retrieval_precision(self,
+                                     func: Optional[Callable] = None,
+                                     *,
+                                     configuration: Optional[AgenticAIConfiguration] = None,
+                                     metrics: list[GenAIMetric] = []
+                                     ) -> dict:
+        """
+        An evaluation decorator for computing retrieval precision metric on an agentic node.
+        """
+        if func is None:
+            return partial(self.evaluate_retrieval_precision, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [RetrievalPrecisionMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(RetrievalPrecisionMetric, ContextRelevanceMetric))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+                metric_outputs = [EvaluatorFields.CONTEXT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=metric_outputs)
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating retrieval precision metric on {func.__name__},") from ex
+
+        return wrapper(func)

ibm_watsonx_gov/metrics/retrieval_precision/retrieval_precision_metric.py

@@ -0,0 +1,170 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from typing import Annotated, Any, Literal
+
+import pandas as pd
+from pydantic import Field, TypeAdapter, field_validator
+
+from ibm_watsonx_gov.config import AgenticAIConfiguration, GenAIConfiguration
+from ibm_watsonx_gov.entities.enums import MetricGroup, TaskType
+from ibm_watsonx_gov.entities.evaluation_result import (AggregateMetricResult,
+                                                        RecordMetricResult)
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.entities.metric_threshold import MetricThreshold
+from ibm_watsonx_gov.metrics.context_relevance.context_relevance_metric import (
+    CONTEXT_RELEVANCE, ContextRelevanceMetric, ContextRelevanceResult)
+
+RETRIEVAL_PRECISION = "retrieval_precision"
+RETRIEVAL_PRECISION_DISPLAY_NAME = "Retrieval Precision"
+
+
+class RetrievalPrecisionResult(RecordMetricResult):
+    name: str = RETRIEVAL_PRECISION
+    display_name: str = RETRIEVAL_PRECISION_DISPLAY_NAME
+    group: MetricGroup = MetricGroup.RETRIEVAL_QUALITY
+
+
+class RetrievalPrecisionMetric(GenAIMetric):
+    """
+    Defines the Retrieval Precision metric class.
+
+    The Retrieval Precision metric measures the quanity of relevant contexts from the total of contexts that are retrieved.
+    The Context Relevance metric is computed as a pre requisite to compute this metric.
+
+    Examples:
+        1. Create Retrieval Precision metric with default parameters and compute using metrics evaluator.
+            .. code-block:: python
+
+                metric = RetrievalPrecisionMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": "..."},
+                                                    metrics=[metric])
+                # A list of contexts can also be passed as shown below
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": ["...", "..."]},
+                                                    metrics=[metric])
+
+        2. Create Retrieval Precision metric with a custom threshold.
+            .. code-block:: python
+
+                threshold  = MetricThreshold(type="lower_limit", value=0.5)
+                metric = RetrievalPrecisionMetric(method=method, threshold=threshold)
+
+        3. Create Retrieval Precision metric with llm_as_judge method.
+            .. code-block:: python
+
+                # Define LLM Judge using watsonx.ai
+                # To use other frameworks and models as llm_judge, see :module:`ibm_watsonx_gov.entities.foundation_model`
+                llm_judge = LLMJudge(model=WxAIFoundationModel(
+                                            model_id="ibm/granite-3-3-8b-instruct",
+                                            project_id="<PROJECT_ID>"
+                                    ))
+                cr_metric = ContextRelevanceMetric(llm_judge=llm_judge)
+                ap_metric = RetrievalPrecisionMetric()
+                result = MetricsEvaluator().evaluate(data={"input_text": "...", "context": ["...", "..."]},
+                                                    metrics=[cr_metric, ap_metric])
+    """
+    name: Annotated[Literal["retrieval_precision"],
+                    Field(title="Name",
+                          description="The retrieval precision metric name.",
+                          default=RETRIEVAL_PRECISION, frozen=True)]
+    display_name: Annotated[Literal["Retrieval Precision"],
+                            Field(title="Display Name",
+                                  description="The retrieval precision metric display name.",
+                                  default=RETRIEVAL_PRECISION_DISPLAY_NAME, frozen=True)]
+    tasks: Annotated[list[TaskType],
+                     Field(title="Tasks",
+                           description="The list of supported tasks.",
+                           default=[TaskType.RAG])]
+    thresholds: Annotated[list[MetricThreshold],
+                          Field(title="Thresholds",
+                                description="The metric thresholds.",
+                                default=[MetricThreshold(type="lower_limit", value=0.7)])]
+    metric_dependencies: Annotated[list[GenAIMetric],
+                                   Field(title="Metric dependencies",
+                                         description="The list of metric dependencies",
+                                         default=[ContextRelevanceMetric()])]
+    group: Annotated[MetricGroup,
+                     Field(title="Group",
+                           description="The metric group.",
+                           default=MetricGroup.RETRIEVAL_QUALITY, frozen=True)]
+
+    @field_validator("metric_dependencies", mode="before")
+    @classmethod
+    def metric_dependencies_validator(cls, value: Any):
+        if value:
+            value = [TypeAdapter(Annotated[ContextRelevanceMetric, Field(
+                discriminator="name")]).validate_python(
+                m) for m in value]
+        return value
+
+    def evaluate(
+            self,
+            data: pd.DataFrame,
+            configuration: GenAIConfiguration | AgenticAIConfiguration,
+            metrics_result: list[AggregateMetricResult],
+            **kwargs,
+    ) -> AggregateMetricResult:
+        record_level_metrics = []
+        scores = []
+
+        context_relevance_result: list[ContextRelevanceResult] = next(
+            (metric_result.record_level_metrics for metric_result in metrics_result if metric_result.name == CONTEXT_RELEVANCE), None)
+
+        if context_relevance_result is None:
+            raise Exception(
+                f"Failed to evaluate {self.name} metric. Missing context relevance metric result")
+
+        for relevance_result in context_relevance_result:
+            score = self.__compute(
+                relevance_scores=relevance_result.additional_info.get(
+                    "contexts_values", []),
+                threshold=self.thresholds[0].value,
+            )
+            scores.append(score)
+            record_level_metrics.append(
+                RetrievalPrecisionResult(
+                    method="",
+                    provider="",
+                    record_id=relevance_result.record_id,
+                    value=score,
+                    thresholds=self.thresholds,
+                )
+            )
+
+        mean = sum(scores) / len(scores)
+        aggregate_metric_score = AggregateMetricResult(
+            name=self.name,
+            display_name=self.display_name,
+            method="",
+            provider="",
+            group=self.group,
+            min=min(scores),
+            max=max(scores),
+            mean=mean,
+            value=mean,
+            total_records=len(record_level_metrics),
+            record_level_metrics=record_level_metrics,
+            thresholds=self.thresholds,
+        )
+
+        return aggregate_metric_score
+
+    def __compute(self, relevance_scores: list[float], threshold: float) -> float:
+        relevance_list = []
+        # Total Number of Contexts Retrieved
+        total_no_of_contexts = len(relevance_scores)
+        for r in relevance_scores:
+            if r >= threshold:
+                relevance_list.append(1)  # True positive
+            else:
+                relevance_list.append(0)  # False positive
+        precision = sum(relevance_list) / \
+            total_no_of_contexts if total_no_of_contexts > 0 else 0
+        precision = round(precision, 4)
+        return precision

ibm_watsonx_gov/metrics/sexual_content/__init__.py

@@ -0,0 +1,8 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------

ibm_watsonx_gov/metrics/sexual_content/sexual_content_decorator.py

@@ -0,0 +1,61 @@
+# ----------------------------------------------------------------------------------------------------
+# IBM Confidential
+# Licensed Materials - Property of IBM
+# 5737-H76, 5900-A3Q
+# © Copyright IBM Corp. 2025  All Rights Reserved.
+# US Government Users Restricted Rights - Use, duplication or disclosure restricted by
+# GSA ADPSchedule Contract with IBM Corp.
+# ----------------------------------------------------------------------------------------------------
+
+from functools import partial
+from typing import Callable, Optional
+
+from wrapt import decorator
+
+from ibm_watsonx_gov.config.agentic_ai_configuration import \
+    AgenticAIConfiguration
+from ibm_watsonx_gov.entities.enums import EvaluatorFields
+from ibm_watsonx_gov.entities.metric import GenAIMetric
+from ibm_watsonx_gov.metrics.base_metric_decorator import BaseMetricDecorator
+from ibm_watsonx_gov.metrics.sexual_content.sexual_content_metric import \
+    SexualContentMetric
+
+
+class SexualContentDecorator(BaseMetricDecorator):
+
+    def evaluate_sexual_content(self,
+                                func: Optional[Callable] = None,
+                                *,
+                                configuration: Optional[AgenticAIConfiguration] = None,
+                                metrics: list[GenAIMetric] = []
+                                ) -> dict:
+        """
+        An evaluation decorator for computing sexual content on an agentic node via granite guardian.
+        """
+        if func is None:
+            return partial(self.evaluate_sexual_content, configuration=configuration, metrics=metrics)
+
+        if not metrics:
+            metrics = [SexualContentMetric()]
+
+        @decorator
+        def wrapper(func, instance, args, kwargs):
+
+            try:
+                self.validate(func=func, metrics=metrics,
+                              valid_metric_types=(SexualContentMetric))
+
+                metric_inputs = [EvaluatorFields.INPUT_FIELDS]
+
+                original_result = self.compute_helper(func=func, args=args, kwargs=kwargs,
+                                                      configuration=configuration,
+                                                      metrics=metrics,
+                                                      metric_inputs=metric_inputs,
+                                                      metric_outputs=[])
+
+                return original_result
+            except Exception as ex:
+                raise Exception(
+                    f"There was an error while evaluating sexual content on {func.__name__},") from ex
+
+        return wrapper(func)