Migrate wrapper prompts

Author: rhlbhatnagar

src/ragas/metrics/collections/__init__.py

@@ -15,8 +15,10 @@
 from ragas.metrics.collections._bleu_score import BleuScore
 from ragas.metrics.collections._context_entity_recall import ContextEntityRecall
 from ragas.metrics.collections._context_precision import (
+    ContextPrecision,
     ContextPrecisionWithoutReference,
     ContextPrecisionWithReference,
+    ContextUtilization,
 )
 from ragas.metrics.collections._faithfulness import Faithfulness
 from ragas.metrics.collections._noise_sensitivity import NoiseSensitivity
@@ -41,9 +43,11 @@
     "AspectCritic",
     "BleuScore",
     "ContextEntityRecall",
+    "ContextPrecision",
     "ContextPrecisionWithReference",
     "ContextPrecisionWithoutReference",
     "ContextRelevance",
+    "ContextUtilization",
     "DistanceMeasure",
     "ExactMatch",
     "Faithfulness",

src/ragas/metrics/collections/_context_precision.py

@@ -256,3 +256,75 @@ def _calculate_average_precision(self, verdicts: List[int]) -> float:
             )
 
         return score
+
+
+class ContextPrecision(ContextPrecisionWithReference):
+    """
+    Modern v2 wrapper for ContextPrecisionWithReference with shorter name.
+
+    This is a simple wrapper that provides the legacy "context_precision" name
+    while using the modern V2 implementation underneath.
+
+    Usage:
+        >>> import openai
+        >>> from ragas.llms.base import llm_factory
+        >>> from ragas.metrics.collections import ContextPrecision
+        >>>
+        >>> # Setup dependencies
+        >>> client = openai.AsyncOpenAI()
+        >>> llm = llm_factory("gpt-4o-mini", client=client)
+        >>>
+        >>> # Create metric instance (same as ContextPrecisionWithReference)
+        >>> metric = ContextPrecision(llm=llm)
+        >>>
+        >>> # Single evaluation
+        >>> result = await metric.ascore(
+        ...     user_input="What is the capital of France?",
+        ...     reference="Paris is the capital of France.",
+        ...     retrieved_contexts=["Paris is the capital and largest city of France."]
+        ... )
+    """
+
+    def __init__(
+        self,
+        llm: "InstructorBaseRagasLLM",
+        **kwargs,
+    ):
+        """Initialize ContextPrecision with the legacy default name."""
+        super().__init__(llm, name="context_precision", **kwargs)
+
+
+class ContextUtilization(ContextPrecisionWithoutReference):
+    """
+    Modern v2 wrapper for ContextPrecisionWithoutReference with shorter name.
+
+    This is a simple wrapper that provides the legacy "context_utilization" name
+    while using the modern V2 implementation underneath.
+
+    Usage:
+        >>> import openai
+        >>> from ragas.llms.base import llm_factory
+        >>> from ragas.metrics.collections import ContextUtilization
+        >>>
+        >>> # Setup dependencies
+        >>> client = openai.AsyncOpenAI()
+        >>> llm = llm_factory("gpt-4o-mini", client=client)
+        >>>
+        >>> # Create metric instance (same as ContextPrecisionWithoutReference)
+        >>> metric = ContextUtilization(llm=llm)
+        >>>
+        >>> # Single evaluation
+        >>> result = await metric.ascore(
+        ...     user_input="What is the capital of France?",
+        ...     response="Paris is the capital of France.",
+        ...     retrieved_contexts=["Paris is the capital and largest city of France."]
+        ... )
+    """
+
+    def __init__(
+        self,
+        llm: "InstructorBaseRagasLLM",
+        **kwargs,
+    ):
+        """Initialize ContextUtilization with the legacy default name."""
+        super().__init__(llm, name="context_utilization", **kwargs)

tests/e2e/metrics_migration/test_context_precision_migration.py

@@ -8,8 +8,10 @@
     LLMContextPrecisionWithReference as LegacyContextPrecisionWithReference,
 )
 from ragas.metrics.collections import (
+    ContextPrecision,
     ContextPrecisionWithoutReference,
     ContextPrecisionWithReference,
+    ContextUtilization,
 )
 
 
@@ -255,3 +257,65 @@ async def test_context_precision_edge_cases(self, test_modern_llm):
             retrieved_contexts=["In mathematics, 2+2 equals 4."],
         )
         assert 0.0 <= result.value <= 1.0
+
+    @pytest.mark.asyncio
+    async def test_context_precision_wrappers(self, test_modern_llm):
+        """Test that the wrapper classes work identically to their base classes."""
+
+        if test_modern_llm is None:
+            pytest.skip("Modern LLM required for wrapper testing")
+
+        test_data = {
+            "user_input": "What is the capital of France?",
+            "reference": "Paris is the capital of France.",
+            "response": "Paris is the capital of France.",
+            "retrieved_contexts": ["Paris is the capital and largest city of France."],
+        }
+
+        # Test ContextPrecision wrapper vs ContextPrecisionWithReference
+        wrapper = ContextPrecision(llm=test_modern_llm)
+        base = ContextPrecisionWithReference(llm=test_modern_llm)
+
+        wrapper_result = await wrapper.ascore(
+            user_input=test_data["user_input"],
+            reference=test_data["reference"],
+            retrieved_contexts=test_data["retrieved_contexts"],
+        )
+
+        base_result = await base.ascore(
+            user_input=test_data["user_input"],
+            reference=test_data["reference"],
+            retrieved_contexts=test_data["retrieved_contexts"],
+        )
+
+        # Should have the correct names
+        assert wrapper.name == "context_precision"
+        assert base.name == "context_precision_with_reference"
+
+        # Should produce identical scores
+        assert wrapper_result.value == base_result.value
+        print(f"✅ ContextPrecision wrapper works correctly: {wrapper_result.value}")
+
+        # Test ContextUtilization wrapper vs ContextPrecisionWithoutReference
+        wrapper2 = ContextUtilization(llm=test_modern_llm)
+        base2 = ContextPrecisionWithoutReference(llm=test_modern_llm)
+
+        wrapper2_result = await wrapper2.ascore(
+            user_input=test_data["user_input"],
+            response=test_data["response"],
+            retrieved_contexts=test_data["retrieved_contexts"],
+        )
+
+        base2_result = await base2.ascore(
+            user_input=test_data["user_input"],
+            response=test_data["response"],
+            retrieved_contexts=test_data["retrieved_contexts"],
+        )
+
+        # Should have the correct names
+        assert wrapper2.name == "context_utilization"
+        assert base2.name == "context_precision_without_reference"
+
+        # Should produce identical scores
+        assert wrapper2_result.value == base2_result.value
+        print(f"✅ ContextUtilization wrapper works correctly: {wrapper2_result.value}")