opik 1.6.4__py3-none-any.whl → 1.9.71__py3-none-any.whl

opik/evaluation/metrics/heuristics/vader_sentiment.py

@@ -0,0 +1,77 @@
+"""VADER sentiment metric wrapper."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from opik.evaluation.metrics.base_metric import BaseMetric
+from opik.evaluation.metrics.score_result import ScoreResult
+from opik.exceptions import MetricComputationError
+
+try:  # pragma: no cover - optional dependency
+    from nltk.sentiment import SentimentIntensityAnalyzer
+except ImportError:  # pragma: no cover - optional dependency
+    SentimentIntensityAnalyzer = None  # type: ignore
+
+
+class VADERSentiment(BaseMetric):
+    """
+    Compute the VADER compound sentiment for a piece of text.
+
+    References:
+      - Hutto & Gilbert, "VADER: A Parsimonious Rule-based Model for Sentiment Analysis of
+        Social Media Text" (ICWSM 2014)
+        https://ojs.aaai.org/index.php/ICWSM/article/view/14550
+      - VADER Sentiment GitHub repository (official implementation)
+        https://github.com/cjhutto/vaderSentiment
+
+    Args:
+        name: Display name for the metric result. Defaults to
+            ``"vader_sentiment_metric"``.
+        track: Whether to automatically track metric results. Defaults to ``True``.
+        project_name: Optional tracking project name. Defaults to ``None``.
+        analyzer: Optional pre-initialised ``SentimentIntensityAnalyzer`` or
+            compatible callable.
+
+    Example:
+        >>> from opik.evaluation.metrics import VADERSentiment
+        >>> metric = VADERSentiment()
+        >>> result = metric.score("I absolutely love this experience!")  # doctest: +SKIP
+        >>> round(result.value, 2)  # doctest: +SKIP
+        0.94
+    """
+
+    def __init__(
+        self,
+        name: str = "vader_sentiment_metric",
+        track: bool = True,
+        project_name: Optional[str] = None,
+        analyzer: Optional[Any] = None,
+    ) -> None:
+        super().__init__(name=name, track=track, project_name=project_name)
+
+        if analyzer is not None:
+            self._analyzer = analyzer
+        else:
+            if (
+                SentimentIntensityAnalyzer is None
+            ):  # pragma: no cover - optional dependency
+                raise ImportError(
+                    "VADER sentiment metric requires the optional 'nltk' package. Install via"
+                    " `pip install nltk` or provide a custom analyzer."
+                )
+            self._analyzer = SentimentIntensityAnalyzer()
+
+    def score(self, output: str, **ignored_kwargs: Any) -> ScoreResult:
+        if not output or not output.strip():
+            raise MetricComputationError("Text is empty (VADERSentiment).")
+
+        scores = self._analyzer.polarity_scores(output)
+        compound = float(scores.get("compound", 0.0))
+        normalized = (compound + 1.0) / 2.0
+        return ScoreResult(
+            value=normalized,
+            name=self.name,
+            reason=f"VADER compound score (normalized): {normalized:.4f}",
+            metadata={"vader": scores},
+        )

opik/evaluation/metrics/llm_judges/answer_relevance/metric.py

@@ -1,16 +1,11 @@
-import json
-import logging
 from typing import Any, List, Optional, Union
 import pydantic
 
-from opik import logging_messages
 from opik.evaluation.metrics import base_metric, score_result
 from opik.evaluation.models import base_model, models_factory
 
-from . import templates
-from opik import exceptions
-
-LOGGER = logging.getLogger(__name__)
+from . import templates, parser
+import opik.exceptions as exceptions
 
 
 class AnswerRelevanceResponseFormat(pydantic.BaseModel):
@@ -36,6 +31,9 @@ class AnswerRelevance(base_metric.BaseMetric):
             If not provided, Opik's generic examples will be used.
         require_context: if set to False, execution in no-context mode is allowed. Default is True.
         track: Whether to track the metric. Defaults to True.
+        project_name: Optional project name to track the metric in for the cases when there are no parent span/trace to inherit project name from.
+        seed: Optional seed value for reproducible model generation. If provided, this seed will be passed to the model for deterministic outputs.
+        temperature: Optional temperature value for model generation. If provided, this temperature will be passed to the model. If not provided, the model's default temperature will be used.
 
     Example:
         >>> from opik.evaluation.metrics import AnswerRelevance
@@ -59,25 +57,38 @@ class AnswerRelevance(base_metric.BaseMetric):
         ] = None,
         require_context: bool = True,
         track: bool = True,
+        project_name: Optional[str] = None,
+        seed: Optional[int] = None,
+        temperature: Optional[float] = None,
     ):
         super().__init__(
             name=name,
             track=track,
+            project_name=project_name,
         )
         self._require_context = require_context
-        self._init_model(model)
+        self._seed = seed
+        self._init_model(model, temperature=temperature)
         self._init_few_shot_examples(
             few_shot_examples_with_context=few_shot_examples,
             few_shot_examples_no_context=few_shot_examples_no_context,
         )
 
     def _init_model(
-        self, model: Optional[Union[str, base_model.OpikBaseModel]]
+        self,
+        model: Optional[Union[str, base_model.OpikBaseModel]],
+        temperature: Optional[float],
     ) -> None:
         if isinstance(model, base_model.OpikBaseModel):
             self._model = model
         else:
-            self._model = models_factory.get(model_name=model)
+            model_kwargs = {}
+            if temperature is not None:
+                model_kwargs["temperature"] = temperature
+            if self._seed is not None:
+                model_kwargs["seed"] = self._seed
+
+            self._model = models_factory.get(model_name=model, **model_kwargs)
 
     def _init_few_shot_examples(
         self,
@@ -126,9 +137,10 @@ class AnswerRelevance(base_metric.BaseMetric):
         )
 
         model_output = self._model.generate_string(
-            input=llm_query, response_format=AnswerRelevanceResponseFormat
+            input=llm_query,
+            response_format=AnswerRelevanceResponseFormat,
         )
-        return self._parse_model_output(model_output)
+        return parser.parse_model_output(content=model_output, name=self.name)
 
     async def ascore(
         self,
@@ -156,26 +168,11 @@ class AnswerRelevance(base_metric.BaseMetric):
             input=input, output=output, context=context
         )
         model_output = await self._model.agenerate_string(
-            input=llm_query, response_format=AnswerRelevanceResponseFormat
+            input=llm_query,
+            response_format=AnswerRelevanceResponseFormat,
         )
 
-        return self._parse_model_output(model_output)
-
-    def _parse_model_output(self, content: str) -> score_result.ScoreResult:
-        try:
-            dict_content = json.loads(content)
-            score: float = dict_content["answer_relevance_score"]
-
-            if not (0.0 <= score <= 1.0):
-                score = 0.5
-
-            return score_result.ScoreResult(
-                name=self.name, value=score, reason=dict_content["reason"]
-            )
-        except Exception:
-            raise exceptions.MetricComputationError(
-                logging_messages.ANSWER_RELEVANCE_SCORE_CALC_FAILED
-            )
+        return parser.parse_model_output(content=model_output, name=self.name)
 
     def _generate_llm_query(
         self, input: str, output: str, context: Optional[List[str]]

opik/evaluation/metrics/llm_judges/answer_relevance/parser.py

@@ -0,0 +1,27 @@
+import logging
+import opik.exceptions as exceptions
+import opik.logging_messages as logging_messages
+from opik.evaluation.metrics import score_result
+from opik.evaluation.metrics.llm_judges import parsing_helpers
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse_model_output(content: str, name: str) -> score_result.ScoreResult:
+    try:
+        dict_content = parsing_helpers.extract_json_content_or_raise(content)
+        score: float = dict_content["answer_relevance_score"]
+
+        if not (0.0 <= score <= 1.0):
+            raise exceptions.MetricComputationError(
+                f"Answer relevance score must be between 0.0 and 1.0, got {score}"
+            )
+
+        return score_result.ScoreResult(
+            name=name, value=score, reason=dict_content["reason"]
+        )
+    except Exception as e:
+        LOGGER.error(f"Failed to parse model output: {e}", exc_info=True)
+        raise exceptions.MetricComputationError(
+            logging_messages.ANSWER_RELEVANCE_SCORE_CALC_FAILED
+        )

opik/evaluation/metrics/llm_judges/answer_relevance/templates.py

@@ -87,15 +87,15 @@ def generate_query_with_context(
 ) -> str:
     examples_str = "\n\n".join(
         [
-            f"#### Example {i+1}: {example['title']}\n\n"
-            f"- **Input:** \"{example['input']}\"\n"
-            f"- **Output:** \"{example['output']}\"\n"
+            f"#### Example {i + 1}: {example['title']}\n\n"
+            f'- **Input:** "{example["input"]}"\n'
+            f'- **Output:** "{example["output"]}"\n'
             f"- **Context:** {example['context']}\n"
             f"- **Result:**\n"
             f"  ```json\n"
             f"  {{\n"
-            f"    \"answer_relevance_score\": {example['answer_relevance_score']},\n"
-            f"    \"reason\": \"{example['reason']}\"\n"
+            f'    "answer_relevance_score": {example["answer_relevance_score"]},\n'
+            f'    "reason": "{example["reason"]}"\n'
             f"  }}\n"
             f"  ```"
             for i, example in enumerate(few_shot_examples)
@@ -171,14 +171,14 @@ def generate_query_no_context(
 ) -> str:
     examples_str = "\n\n".join(
         [
-            f"#### Example {i+1}: {example['title']}\n\n"
-            f"- **Input:** \"{example['input']}\"\n"
-            f"- **Output:** \"{example['output']}\"\n"
+            f"#### Example {i + 1}: {example['title']}\n\n"
+            f'- **Input:** "{example["input"]}"\n'
+            f'- **Output:** "{example["output"]}"\n'
             f"- **Result:**\n"
             f"  ```json\n"
             f"  {{\n"
-            f"    \"answer_relevance_score\": {example['answer_relevance_score']},\n"
-            f"    \"reason\": \"{example['reason']}\"\n"
+            f'    "answer_relevance_score": {example["answer_relevance_score"]},\n'
+            f'    "reason": "{example["reason"]}"\n'
             f"  }}\n"
             f"  ```"
             for i, example in enumerate(few_shot_examples)

opik/evaluation/metrics/llm_judges/context_precision/metric.py

@@ -1,15 +1,10 @@
-import json
-import logging
 from typing import Any, List, Optional, Union
+
 import pydantic
-from opik import logging_messages
 from opik.evaluation.metrics import base_metric, score_result
 from opik.evaluation.models import base_model, models_factory
 
-from . import template
-from opik import exceptions
-
-LOGGER = logging.getLogger(__name__)
+from . import template, parser
 
 
 class ContextPrecisionResponseFormat(pydantic.BaseModel):
@@ -31,6 +26,10 @@ class ContextPrecision(base_metric.BaseMetric):
         name: The name of the metric. Defaults to "context_precision_metric".
         few_shot_examples: A list of few-shot examples to provide to the model. If None, uses the default few-shot examples.
         track: Whether to track the metric. Defaults to True.
+        project_name: Optional project name to track the metric in for the cases when
+            there are no parent span/trace to inherit project name from.
+        seed: Optional seed value for reproducible model generation. If provided, this seed will be passed to the model for deterministic outputs.
+        temperature: Optional temperature value for model generation. If provided, this temperature will be passed to the model. If not provided, the model's default temperature will be used.
 
     Example:
         >>> from opik.evaluation.metrics import ContextPrecision
@@ -50,22 +49,34 @@ class ContextPrecision(base_metric.BaseMetric):
             List[template.FewShotExampleContextPrecision]
         ] = None,
         track: bool = True,
+        project_name: Optional[str] = None,
+        seed: Optional[int] = None,
+        temperature: Optional[float] = None,
     ):
         super().__init__(
             name=name,
             track=track,
+            project_name=project_name,
         )
-
-        self._init_model(model)
+        self._seed = seed
+        self._init_model(model, temperature=temperature)
         self.few_shot_examples = few_shot_examples or template.FEW_SHOT_EXAMPLES
 
     def _init_model(
-        self, model: Optional[Union[str, base_model.OpikBaseModel]]
+        self,
+        model: Optional[Union[str, base_model.OpikBaseModel]],
+        temperature: Optional[float],
     ) -> None:
         if isinstance(model, base_model.OpikBaseModel):
             self._model = model
         else:
-            self._model = models_factory.get(model_name=model)
+            model_kwargs = {}
+            if temperature is not None:
+                model_kwargs["temperature"] = temperature
+            if self._seed is not None:
+                model_kwargs["seed"] = self._seed
+
+            self._model = models_factory.get(model_name=model, **model_kwargs)
 
     def score(
         self,
@@ -97,10 +108,11 @@ class ContextPrecision(base_metric.BaseMetric):
             few_shot_examples=self.few_shot_examples,
         )
         model_output = self._model.generate_string(
-            input=llm_query, response_format=ContextPrecisionResponseFormat
+            input=llm_query,
+            response_format=ContextPrecisionResponseFormat,
         )
 
-        return self._parse_model_output(model_output)
+        return parser.parse_model_output(content=model_output, name=self.name)
 
     async def ascore(
         self,
@@ -134,23 +146,8 @@ class ContextPrecision(base_metric.BaseMetric):
             few_shot_examples=self.few_shot_examples,
         )
         model_output = await self._model.agenerate_string(
-            input=llm_query, response_format=ContextPrecisionResponseFormat
+            input=llm_query,
+            response_format=ContextPrecisionResponseFormat,
         )
 
-        return self._parse_model_output(model_output)
-
-    def _parse_model_output(self, content: str) -> score_result.ScoreResult:
-        try:
-            dict_content = json.loads(content)
-            score: float = float(dict_content["context_precision_score"])
-
-            if not (0.0 <= score <= 1.0):
-                score = 0.5
-
-            return score_result.ScoreResult(
-                name=self.name, value=score, reason=dict_content["reason"]
-            )
-        except Exception:
-            raise exceptions.MetricComputationError(
-                logging_messages.CONTEXT_PRECISION_SCORE_CALC_FAILED
-            )
+        return parser.parse_model_output(content=model_output, name=self.name)

opik/evaluation/metrics/llm_judges/context_precision/parser.py

@@ -0,0 +1,27 @@
+import logging
+import opik.exceptions as exceptions
+import opik.logging_messages as logging_messages
+from opik.evaluation.metrics import score_result
+from opik.evaluation.metrics.llm_judges import parsing_helpers
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse_model_output(content: str, name: str) -> score_result.ScoreResult:
+    try:
+        dict_content = parsing_helpers.extract_json_content_or_raise(content)
+        score: float = float(dict_content["context_precision_score"])
+
+        if not (0.0 <= score <= 1.0):
+            raise exceptions.MetricComputationError(
+                f"Context precision score must be between 0.0 and 1.0, got {score}"
+            )
+
+        return score_result.ScoreResult(
+            name=name, value=score, reason=dict_content["reason"]
+        )
+    except Exception as e:
+        LOGGER.error(f"Failed to parse model output: {e}", exc_info=True)
+        raise exceptions.MetricComputationError(
+            logging_messages.CONTEXT_PRECISION_SCORE_CALC_FAILED
+        )

opik/evaluation/metrics/llm_judges/context_precision/template.py

@@ -51,16 +51,16 @@ def generate_query(
 ) -> str:
     examples_str = "\n\n".join(
         [
-            f"#### Example {i+1}: {example['title']}\n\n"
-            f"- **Input:** \"{example['input']}\"\n"
-            f"- **Output:** \"{example['output']}\"\n"
-            f"- **Expected Output:** \"{example['expected_output']}\"\n"
-            f"- **Context:** \"{example['context']}\"\n"
+            f"#### Example {i + 1}: {example['title']}\n\n"
+            f'- **Input:** "{example["input"]}"\n'
+            f'- **Output:** "{example["output"]}"\n'
+            f'- **Expected Output:** "{example["expected_output"]}"\n'
+            f'- **Context:** "{example["context"]}"\n'
             f"- **Result:**\n"
             f"  ```json\n"
             f"  {{\n"
-            f"    \"context_precision_score\": {example['context_precision_score']},\n"
-            f"    \"reason\": \"{example['reason']}\"\n"
+            f'    "context_precision_score": {example["context_precision_score"]},\n'
+            f'    "reason": "{example["reason"]}"\n'
             f"  }}\n"
             f"  ```"
             for i, example in enumerate(few_shot_examples)

opik/evaluation/metrics/llm_judges/context_recall/metric.py

@@ -1,16 +1,10 @@
-import json
-import logging
 from typing import Any, List, Optional, Union
 import pydantic
 
-from opik import logging_messages
 from opik.evaluation.metrics import base_metric, score_result
 from opik.evaluation.models import base_model, models_factory
 
-from . import template
-from opik import exceptions
-
-LOGGER = logging.getLogger(__name__)
+from . import template, parser
 
 
 class ContextRecallResponseFormat(pydantic.BaseModel):
@@ -32,6 +26,10 @@ class ContextRecall(base_metric.BaseMetric):
         name: The name of the metric. Defaults to "ContextRecallMetric".
         few_shot_examples: A list of few-shot examples to provide to the model. If None, uses the default few-shot examples.
         track: Whether to track the metric. Defaults to True.
+        project_name: Optional project name to track the metric in for the cases when
+            there are no parent span/trace to inherit project name from.
+        seed: Optional seed value for reproducible model generation. If provided, this seed will be passed to the model for deterministic outputs.
+        temperature: Optional temperature value for model generation. If provided, this temperature will be passed to the model. If not provided, the model's default temperature will be used.
 
     Example:
         >>> from opik.evaluation.metrics import ContextRecall
@@ -49,22 +47,34 @@ class ContextRecall(base_metric.BaseMetric):
         name: str = "context_recall_metric",
         few_shot_examples: Optional[List[template.FewShotExampleContextRecall]] = None,
         track: bool = True,
+        project_name: Optional[str] = None,
+        seed: Optional[int] = None,
+        temperature: Optional[float] = None,
     ):
         super().__init__(
             name=name,
             track=track,
+            project_name=project_name,
         )
-
-        self._init_model(model)
+        self._seed = seed
+        self._init_model(model, temperature=temperature)
         self.few_shot_examples = few_shot_examples or template.FEW_SHOT_EXAMPLES
 
     def _init_model(
-        self, model: Optional[Union[str, base_model.OpikBaseModel]]
+        self,
+        model: Optional[Union[str, base_model.OpikBaseModel]],
+        temperature: Optional[float],
     ) -> None:
         if isinstance(model, base_model.OpikBaseModel):
             self._model = model
         else:
-            self._model = models_factory.get(model_name=model)
+            model_kwargs = {}
+            if temperature is not None:
+                model_kwargs["temperature"] = temperature
+            if self._seed is not None:
+                model_kwargs["seed"] = self._seed
+
+            self._model = models_factory.get(model_name=model, **model_kwargs)
 
     def score(
         self,
@@ -96,10 +106,11 @@ class ContextRecall(base_metric.BaseMetric):
             few_shot_examples=self.few_shot_examples,
         )
         model_output = self._model.generate_string(
-            input=llm_query, response_format=ContextRecallResponseFormat
+            input=llm_query,
+            response_format=ContextRecallResponseFormat,
         )
 
-        return self._parse_model_output(model_output)
+        return parser.parse_model_output(content=model_output, name=self.name)
 
     async def ascore(
         self,
@@ -133,23 +144,8 @@ class ContextRecall(base_metric.BaseMetric):
             few_shot_examples=self.few_shot_examples,
         )
         model_output = await self._model.agenerate_string(
-            input=llm_query, response_format=ContextRecallResponseFormat
+            input=llm_query,
+            response_format=ContextRecallResponseFormat,
         )
 
-        return self._parse_model_output(model_output)
-
-    def _parse_model_output(self, content: str) -> score_result.ScoreResult:
-        try:
-            dict_content = json.loads(content)
-            score: float = float(dict_content["context_recall_score"])
-
-            if not (0.0 <= score <= 1.0):
-                score = 0.5
-
-            return score_result.ScoreResult(
-                name=self.name, value=score, reason=dict_content["reason"]
-            )
-        except Exception:
-            raise exceptions.MetricComputationError(
-                logging_messages.CONTEXT_RECALL_SCORE_CALC_FAILED
-            )
+        return parser.parse_model_output(content=model_output, name=self.name)

opik/evaluation/metrics/llm_judges/context_recall/parser.py

@@ -0,0 +1,27 @@
+import logging
+import opik.exceptions as exceptions
+import opik.logging_messages as logging_messages
+from opik.evaluation.metrics import score_result
+from opik.evaluation.metrics.llm_judges import parsing_helpers
+
+LOGGER = logging.getLogger(__name__)
+
+
+def parse_model_output(content: str, name: str) -> score_result.ScoreResult:
+    try:
+        dict_content = parsing_helpers.extract_json_content_or_raise(content)
+        score: float = float(dict_content["context_recall_score"])
+
+        if not (0.0 <= score <= 1.0):
+            raise exceptions.MetricComputationError(
+                f"Context recall score must be between 0.0 and 1.0, got {score}"
+            )
+
+        return score_result.ScoreResult(
+            name=name, value=score, reason=dict_content["reason"]
+        )
+    except Exception as e:
+        LOGGER.error(f"Failed to parse model output: {e}", exc_info=True)
+        raise exceptions.MetricComputationError(
+            logging_messages.CONTEXT_RECALL_SCORE_CALC_FAILED
+        )

opik/evaluation/metrics/llm_judges/context_recall/template.py

@@ -51,16 +51,16 @@ def generate_query(
 ) -> str:
     examples_str = "\n\n".join(
         [
-            f"#### Example {i+1}: {example['title']}\n\n"
-            f"- **Input:** \"{example['input']}\"\n"
-            f"- **Output:** \"{example['output']}\"\n"
-            f"- **Expected Output:** \"{example['expected_output']}\"\n"
-            f"- **Context:** \"{example['context']}\"\n"
+            f"#### Example {i + 1}: {example['title']}\n\n"
+            f'- **Input:** "{example["input"]}"\n'
+            f'- **Output:** "{example["output"]}"\n'
+            f'- **Expected Output:** "{example["expected_output"]}"\n'
+            f'- **Context:** "{example["context"]}"\n'
             f"- **Result:**\n"
             f"  ```json\n"
             f"  {{\n"
-            f"    \"context_recall_score\": {example['context_recall_score']},\n"
-            f"    \"reason\": \"{example['reason']}\"\n"
+            f'    "context_recall_score": {example["context_recall_score"]},\n'
+            f'    "reason": "{example["reason"]}"\n'
             f"  }}\n"
             f"  ```"
             for i, example in enumerate(few_shot_examples)

opik/evaluation/metrics/llm_judges/factuality/metric.py

@@ -1,15 +1,9 @@
-import json
-import logging
 from typing import Union, Optional, List, Any
 import pydantic
 from opik.evaluation.models import base_model, models_factory
 from opik.evaluation.metrics import score_result, base_metric
-from opik import logging_messages
 
-from . import template
-from opik.exceptions import MetricComputationError
-
-LOGGER = logging.getLogger(__name__)
+from . import template, parser
 
 
 class FactualityResponseFormatClaim(pydantic.BaseModel):
@@ -35,6 +29,8 @@ class Factuality(base_metric.BaseMetric):
         name: The name of the metric. Defaults to "FactualityMetric".
         few_shot_examples: A list of few-shot examples to be used in the query. If None, default examples will be used.
         track: Whether to track the metric. Defaults to True.
+        project_name: Optional project name to track the metric in for the cases when
+            there are no parent span/trace to inherit project name from.
 
     Example:
         >>> from opik.evaluation.metrics import Factuality
@@ -50,10 +46,12 @@ class Factuality(base_metric.BaseMetric):
         name: str = "FactualityMetric",
         few_shot_examples: Optional[List[template.FewShotExampleFactuality]] = None,
         track: bool = True,
+        project_name: Optional[str] = None,
     ):
         super().__init__(
             name=name,
             track=track,
+            project_name=project_name,
         )
 
         self._init_model(model)
@@ -93,7 +91,7 @@ class Factuality(base_metric.BaseMetric):
             input=llm_query, response_format=FactualityResponseFormat
         )
 
-        return self._parse_model_output(model_output)
+        return parser.parse_model_output(content=model_output, name=self.name)
 
     async def ascore(
         self, input: str, output: str, context: List[str], **ignored_kwargs: Any
@@ -123,21 +121,4 @@ class Factuality(base_metric.BaseMetric):
             input=llm_query, response_format=FactualityResponseFormat
         )
 
-        return self._parse_model_output(model_output)
-
-    def _parse_model_output(self, content: str) -> score_result.ScoreResult:
-        try:
-            list_content = json.loads(content)
-
-            reason = ""
-            score = 0.0
-
-            for claim in list_content:
-                score += claim["score"]
-                reason += claim["reason"] + "\n"
-
-            score /= len(list_content)
-
-            return score_result.ScoreResult(name=self.name, value=score, reason=reason)
-        except Exception:
-            raise MetricComputationError(logging_messages.FACTUALITY_SCORE_CALC_FAILED)
+        return parser.parse_model_output(content=model_output, name=self.name)