deepeval 3.7.2__py3-none-any.whl → 3.7.3__py3-none-any.whl

deepeval/_version.py

@@ -1 +1 @@
-__version__: str = "3.7.2"
+__version__: str = "3.7.3"

deepeval/benchmarks/human_eval/human_eval.py

@@ -92,7 +92,7 @@ class HumanEval(DeepEvalBaseBenchmark):
         self.predictions: Optional[pd.DataFrame] = None
         self.task_scores: Optional[pd.DataFrame] = None
         self.overall_score: Optional[float] = None
-        self.verbose_mode: bool = (False,)
+        self.verbose_mode: bool = verbose_mode
 
     def evaluate(
         self, model: DeepEvalBaseLLM, *args, k: int = 1, **kwargs
@@ -123,6 +123,7 @@ class HumanEval(DeepEvalBaseBenchmark):
                         task.value,
                         golden.input,
                         prediction,
+                        task_correct,
                         golden.expected_output,
                         score,
                     )

deepeval/dataset/dataset.py

@@ -189,17 +189,35 @@ class EvaluationDataset:
         test_case._dataset_alias = self._alias
         test_case._dataset_id = self._id
         if isinstance(test_case, LLMTestCase):
+            if self._conversational_goldens or self._conversational_test_cases:
+                raise TypeError(
+                    "You cannot add 'LLMTestCase' to a multi-turn dataset."
+                )
             test_case._dataset_rank = len(self._llm_test_cases)
             self._llm_test_cases.append(test_case)
         elif isinstance(test_case, ConversationalTestCase):
+            if self._goldens or self._llm_test_cases:
+                raise TypeError(
+                    "You cannot add 'ConversationalTestCase' to a single-turn dataset."
+                )
+            self._multi_turn = True
             test_case._dataset_rank = len(self._conversational_test_cases)
             self._conversational_test_cases.append(test_case)
 
     def add_golden(self, golden: Union[Golden, ConversationalGolden]):
-        if self._multi_turn:
-            self._add_conversational_golden(golden)
-        else:
+        if isinstance(golden, Golden):
+            if self._conversational_goldens or self._conversational_test_cases:
+                raise TypeError(
+                    "You cannot add 'Golden' to a multi-turn dataset."
+                )
             self._add_golden(golden)
+        else:
+            if self._goldens or self._llm_test_cases:
+                raise TypeError(
+                    "You cannot add 'ConversationalGolden' to a single-turn dataset."
+                )
+            self._multi_turn = True
+            self._add_conversational_golden(golden)
 
     def _add_golden(self, golden: Union[Golden, ConversationalGolden]):
         if isinstance(golden, Golden):
@@ -224,16 +242,16 @@ class EvaluationDataset:
         file_path: str,
         input_col_name: str,
         actual_output_col_name: str,
-        expected_output_col_name: Optional[str] = None,
-        context_col_name: Optional[str] = None,
+        expected_output_col_name: Optional[str] = "expected_output",
+        context_col_name: Optional[str] = "context",
         context_col_delimiter: str = ";",
-        retrieval_context_col_name: Optional[str] = None,
+        retrieval_context_col_name: Optional[str] = "retrieval_context",
         retrieval_context_col_delimiter: str = ";",
-        tools_called_col_name: Optional[str] = None,
+        tools_called_col_name: Optional[str] = "tools_called",
         tools_called_col_delimiter: str = ";",
-        expected_tools_col_name: Optional[str] = None,
+        expected_tools_col_name: Optional[str] = "expected_tools",
         expected_tools_col_delimiter: str = ";",
-        additional_metadata_col_name: Optional[str] = None,
+        additional_metadata_col_name: Optional[str] = "additional_metadata",
     ):
         """
         Load test cases from a CSV file.
@@ -379,6 +397,7 @@ class EvaluationDataset:
         retrieval_context_key_name: Optional[str] = None,
         tools_called_key_name: Optional[str] = None,
         expected_tools_key_name: Optional[str] = None,
+        addtional_metadata_key_name: Optional[str] = None,
         encoding_type: str = "utf-8",
     ):
         """
@@ -431,6 +450,7 @@ class EvaluationDataset:
             tools_called = [ToolCall(**tool) for tool in tools_called_data]
             expected_tools_data = json_obj.get(expected_tools_key_name, [])
             expected_tools = [ToolCall(**tool) for tool in expected_tools_data]
+            # additional_metadata = json_obj.get(addtional_metadata_key_name)
 
             self.add_test_case(
                 LLMTestCase(
@@ -441,6 +461,7 @@ class EvaluationDataset:
                     retrieval_context=retrieval_context,
                     tools_called=tools_called,
                     expected_tools=expected_tools,
+                    # additional_metadata=additional_metadata,
                 )
             )
 
@@ -460,8 +481,8 @@ class EvaluationDataset:
         expected_tools_col_delimiter: str = ";",
         comments_key_name: str = "comments",
         name_key_name: str = "name",
-        source_file_col_name: Optional[str] = None,
-        additional_metadata_col_name: Optional[str] = None,
+        source_file_col_name: Optional[str] = "source_file",
+        additional_metadata_col_name: Optional[str] = "additional_metadata",
         scenario_col_name: Optional[str] = "scenario",
         turns_col_name: Optional[str] = "turns",
         expected_outcome_col_name: Optional[str] = "expected_outcome",
@@ -587,6 +608,7 @@ class EvaluationDataset:
                         context=context,
                         comments=comments,
                         name=name,
+                        additional_metadata=additional_metadata,
                     )
                 )
             else:
@@ -645,6 +667,7 @@ class EvaluationDataset:
                 comments = json_obj.get(comments_key_name)
                 name = json_obj.get(name_key_name)
                 parsed_turns = parse_turns(turns) if turns else []
+                additional_metadata = json_obj.get(additional_metadata_key_name)
 
                 self._multi_turn = True
                 self.goldens.append(
@@ -656,6 +679,7 @@ class EvaluationDataset:
                         context=context,
                         comments=comments,
                         name=name,
+                        additional_metadata=additional_metadata,
                     )
                 )
             else:

deepeval/dataset/utils.py

@@ -24,6 +24,7 @@ def convert_test_cases_to_goldens(
             "retrieval_context": test_case.retrieval_context,
             "tools_called": test_case.tools_called,
             "expected_tools": test_case.expected_tools,
+            "additional_metadata": test_case.additional_metadata,
         }
         goldens.append(Golden(**golden))
     return goldens
@@ -70,6 +71,7 @@ def convert_convo_test_cases_to_convo_goldens(
             "expected_outcome": test_case.expected_outcome,
             "user_description": test_case.user_description,
             "context": test_case.context,
+            "additional_metadata": test_case.additional_metadata,
         }
         goldens.append(ConversationalGolden(**golden))
     return goldens

deepeval/metrics/utils.py

@@ -25,6 +25,7 @@ from deepeval.models import (
     MultimodalOpenAIModel,
     MultimodalGeminiModel,
     MultimodalOllamaModel,
+    MultimodalAzureOpenAIMLLMModel,
     AmazonBedrockModel,
     LiteLLMModel,
     KimiModel,
@@ -514,6 +515,8 @@ def initialize_multimodal_model(
         return MultimodalGeminiModel(), True
     if should_use_ollama_model():
         return MultimodalOllamaModel(), True
+    elif should_use_azure_openai():
+        return MultimodalAzureOpenAIMLLMModel(model_name=model), True
     elif isinstance(model, str) or model is None:
         return MultimodalOpenAIModel(model=model), True
     raise TypeError(

deepeval/models/__init__.py

@@ -21,6 +21,7 @@ from deepeval.models.mlllms import (
     MultimodalOpenAIModel,
     MultimodalOllamaModel,
     MultimodalGeminiModel,
+    MultimodalAzureOpenAIMLLMModel,
 )
 from deepeval.models.embedding_models import (
     OpenAIEmbeddingModel,
@@ -48,6 +49,7 @@ __all__ = [
     "MultimodalOpenAIModel",
     "MultimodalOllamaModel",
     "MultimodalGeminiModel",
+    "MultimodalAzureOpenAIMLLMModel",
     "OpenAIEmbeddingModel",
     "AzureOpenAIEmbeddingModel",
     "LocalEmbeddingModel",

deepeval/models/mlllms/__init__.py

@@ -1,3 +1,4 @@
 from .openai_model import MultimodalOpenAIModel
 from .ollama_model import MultimodalOllamaModel
 from .gemini_model import MultimodalGeminiModel
+from .azure_model import MultimodalAzureOpenAIMLLMModel

deepeval/models/mlllms/azure_model.py

@@ -0,0 +1,334 @@
+from openai.types.chat.chat_completion import ChatCompletion
+from openai import AzureOpenAI, AsyncAzureOpenAI
+from typing import Optional, Tuple, Union, Dict, List
+from pydantic import BaseModel
+from io import BytesIO
+import base64
+
+from deepeval.models import DeepEvalBaseMLLM
+from deepeval.key_handler import ModelKeyValues, KEY_FILE_HANDLER
+from deepeval.test_case import MLLMImage
+from deepeval.models.llms.openai_model import (
+    structured_outputs_models,
+    json_mode_models,
+    model_pricing,
+)
+from deepeval.models.retry_policy import (
+    create_retry_decorator,
+    sdk_retries_for,
+)
+
+from deepeval.models.llms.utils import trim_and_load_json
+from deepeval.models.utils import parse_model_name
+from deepeval.constants import ProviderSlug as PS
+
+
+retry_azure = create_retry_decorator(PS.AZURE)
+
+
+class MultimodalAzureOpenAIMLLMModel(DeepEvalBaseMLLM):
+    def __init__(
+        self,
+        deployment_name: Optional[str] = None,
+        model_name: Optional[str] = None,
+        azure_openai_api_key: Optional[str] = None,
+        openai_api_version: Optional[str] = None,
+        azure_endpoint: Optional[str] = None,
+        temperature: float = 0,
+        generation_kwargs: Optional[Dict] = None,
+        **kwargs,
+    ):
+        # fetch Azure deployment parameters
+        model_name = model_name or KEY_FILE_HANDLER.fetch_data(
+            ModelKeyValues.AZURE_MODEL_NAME
+        )
+        self.deployment_name = deployment_name or KEY_FILE_HANDLER.fetch_data(
+            ModelKeyValues.AZURE_DEPLOYMENT_NAME
+        )
+        self.azure_openai_api_key = (
+            azure_openai_api_key
+            or KEY_FILE_HANDLER.fetch_data(ModelKeyValues.AZURE_OPENAI_API_KEY)
+        )
+        self.openai_api_version = (
+            openai_api_version
+            or KEY_FILE_HANDLER.fetch_data(ModelKeyValues.OPENAI_API_VERSION)
+        )
+        self.azure_endpoint = azure_endpoint or KEY_FILE_HANDLER.fetch_data(
+            ModelKeyValues.AZURE_OPENAI_ENDPOINT
+        )
+        if temperature < 0:
+            raise ValueError("Temperature must be >= 0.")
+        self.temperature = temperature
+
+        # args and kwargs will be passed to the underlying model, in load_model function
+        self.kwargs = kwargs
+        self.generation_kwargs = generation_kwargs or {}
+        super().__init__(parse_model_name(model_name))
+
+    ###############################################
+    # Generate functions
+    ###############################################
+
+    @retry_azure
+    def generate(
+        self,
+        multimodal_input: List[Union[str, MLLMImage]],
+        schema: Optional[BaseModel] = None,
+    ) -> Tuple[Union[str, BaseModel], float]:
+        client = self.load_model(async_mode=False)
+        prompt = self.generate_prompt(multimodal_input)
+
+        if schema:
+            if self.model_name in structured_outputs_models:
+                messages = [{"role": "user", "content": prompt}]
+                completion = client.beta.chat.completions.parse(
+                    model=self.deployment_name,
+                    messages=messages,
+                    response_format=schema,
+                    temperature=self.temperature,
+                )
+                structured_output: BaseModel = completion.choices[
+                    0
+                ].message.parsed
+                cost = self.calculate_cost(
+                    completion.usage.prompt_tokens,
+                    completion.usage.completion_tokens,
+                )
+                return structured_output, cost
+            if self.model_name in json_mode_models:
+                messages = [{"role": "user", "content": prompt}]
+                completion = client.beta.chat.completions.parse(
+                    model=self.deployment_name,
+                    messages=messages,
+                    response_format={"type": "json_object"},
+                    temperature=self.temperature,
+                )
+                json_output = trim_and_load_json(
+                    completion.choices[0].message.content
+                )
+                cost = self.calculate_cost(
+                    completion.usage.prompt_tokens,
+                    completion.usage.completion_tokens,
+                )
+                return schema.model_validate(json_output), cost
+        print("Loading model client:")
+        print(client.base_url)
+        completion = client.chat.completions.create(
+            model=self.deployment_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.temperature,
+            **self.generation_kwargs,
+        )
+        output = completion.choices[0].message.content
+        cost = self.calculate_cost(
+            completion.usage.prompt_tokens, completion.usage.completion_tokens
+        )
+        if schema:
+            json_output = trim_and_load_json(output)
+            return schema.model_validate(json_output), cost
+        else:
+            return output, cost
+
+    @retry_azure
+    async def a_generate(
+        self,
+        multimodal_input: List[Union[str, MLLMImage]],
+        schema: Optional[BaseModel] = None,
+    ) -> Tuple[Union[str, BaseModel], float]:
+        client = self.load_model(async_mode=True)
+        prompt = self.generate_prompt(multimodal_input)
+
+        if schema:
+            if self.model_name in structured_outputs_models:
+                messages = [{"role": "user", "content": prompt}]
+                completion = await client.beta.chat.completions.parse(
+                    model=self.deployment_name,
+                    messages=messages,
+                    response_format=schema,
+                    temperature=self.temperature,
+                )
+                structured_output: BaseModel = completion.choices[
+                    0
+                ].message.parsed
+                cost = self.calculate_cost(
+                    completion.usage.prompt_tokens,
+                    completion.usage.completion_tokens,
+                )
+                return structured_output, cost
+            if self.model_name in json_mode_models:
+                messages = [{"role": "user", "content": prompt}]
+                completion = await client.beta.chat.completions.parse(
+                    model=self.deployment_name,
+                    messages=messages,
+                    response_format={"type": "json_object"},
+                    temperature=self.temperature,
+                    **self.generation_kwargs,
+                )
+                json_output = trim_and_load_json(
+                    completion.choices[0].message.content
+                )
+                cost = self.calculate_cost(
+                    completion.usage.prompt_tokens,
+                    completion.usage.completion_tokens,
+                )
+                return schema.model_validate(json_output), cost
+
+        completion = await client.chat.completions.create(
+            model=self.deployment_name,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.temperature,
+            **self.generation_kwargs,
+        )
+        output = completion.choices[0].message.content
+        cost = self.calculate_cost(
+            completion.usage.prompt_tokens,
+            completion.usage.completion_tokens,
+        )
+        if schema:
+            json_output = trim_and_load_json(output)
+            return schema.model_validate(json_output), cost
+        else:
+            return output, cost
+
+    ###############################################
+    # Other generate functions
+    ###############################################
+
+    @retry_azure
+    def generate_raw_response(
+        self,
+        multimodal_input: List[Union[str, MLLMImage]],
+        top_logprobs: int = 5,
+    ) -> Tuple[ChatCompletion, float]:
+        client = self.load_model(async_mode=False)
+        prompt = self.generate_prompt(multimodal_input)
+        messages = [{"role": "user", "content": prompt}]
+
+        # Generate completion
+        completion = client.chat.completions.create(
+            model=self.deployment_name,
+            messages=messages,
+            temperature=self.temperature,
+            logprobs=True,
+            top_logprobs=top_logprobs,
+            **self.generation_kwargs,
+        )
+        # Cost calculation
+        input_tokens = completion.usage.prompt_tokens
+        output_tokens = completion.usage.completion_tokens
+        cost = self.calculate_cost(input_tokens, output_tokens)
+
+        return completion, cost
+
+    @retry_azure
+    async def a_generate_raw_response(
+        self,
+        multimodal_input: List[Union[str, MLLMImage]],
+        top_logprobs: int = 5,
+    ) -> Tuple[ChatCompletion, float]:
+        client = self.load_model(async_mode=True)
+        prompt = self.generate_prompt(multimodal_input)
+        messages = [{"role": "user", "content": prompt}]
+
+        # Generate completion
+        completion = await client.chat.completions.create(
+            model=self.deployment_name,
+            messages=messages,
+            temperature=self.temperature,
+            logprobs=True,
+            top_logprobs=top_logprobs,
+            **self.generation_kwargs,
+        )
+        # Cost calculation
+        input_tokens = completion.usage.prompt_tokens
+        output_tokens = completion.usage.completion_tokens
+        cost = self.calculate_cost(input_tokens, output_tokens)
+
+        return completion, cost
+
+    ###############################################
+    # Utilities
+    ###############################################
+
+    def generate_prompt(
+        self, multimodal_input: List[Union[str, MLLMImage]] = []
+    ):
+        """Convert multimodal input into the proper message format for Azure OpenAI."""
+        prompt = []
+        for ele in multimodal_input:
+            if isinstance(ele, str):
+                prompt.append({"type": "text", "text": ele})
+            elif isinstance(ele, MLLMImage):
+                if ele.local:
+                    import PIL.Image
+
+                    image = PIL.Image.open(ele.url)
+                    visual_dict = {
+                        "type": "image_url",
+                        "image_url": {
+                            "url": f"data:image/jpeg;base64,{self.encode_pil_image(image)}"
+                        },
+                    }
+                else:
+                    visual_dict = {
+                        "type": "image_url",
+                        "image_url": {"url": ele.url},
+                    }
+                prompt.append(visual_dict)
+        return prompt
+
+    def encode_pil_image(self, pil_image):
+        """Encode a PIL image to base64 string."""
+        image_buffer = BytesIO()
+        if pil_image.mode in ("RGBA", "LA", "P"):
+            pil_image = pil_image.convert("RGB")
+        pil_image.save(image_buffer, format="JPEG")
+        image_bytes = image_buffer.getvalue()
+        base64_encoded_image = base64.b64encode(image_bytes).decode("utf-8")
+        return base64_encoded_image
+
+    def calculate_cost(self, input_tokens: int, output_tokens: int) -> float:
+        pricing = model_pricing.get(self.model_name, model_pricing["gpt-4.1"])
+        input_cost = input_tokens * pricing["input"]
+        output_cost = output_tokens * pricing["output"]
+        return input_cost + output_cost
+
+    ###############################################
+    # Model
+    ###############################################
+
+    def get_model_name(self):
+        return f"Azure OpenAI ({self.model_name})"
+
+    def load_model(self, async_mode: bool = False):
+        if not async_mode:
+            return self._build_client(AzureOpenAI)
+        return self._build_client(AsyncAzureOpenAI)
+
+    def _client_kwargs(self) -> Dict:
+        """
+        If Tenacity is managing retries, force OpenAI SDK retries off to avoid double retries.
+        If the user opts into SDK retries for 'azure' via DEEPEVAL_SDK_RETRY_PROVIDERS,
+        leave their retry settings as is.
+        """
+        kwargs = dict(self.kwargs or {})
+        if not sdk_retries_for(PS.AZURE):
+            kwargs["max_retries"] = 0
+        return kwargs
+
+    def _build_client(self, cls):
+        kw = dict(
+            api_key=self.azure_openai_api_key,
+            api_version=self.openai_api_version,
+            azure_endpoint=self.azure_endpoint,
+            azure_deployment=self.deployment_name,
+            **self._client_kwargs(),
+        )
+        try:
+            return cls(**kw)
+        except TypeError as e:
+            # older OpenAI SDKs may not accept max_retries, in that case remove and retry once
+            if "max_retries" in str(e):
+                kw.pop("max_retries", None)
+                return cls(**kw)
+            raise

deepeval/tracing/context.py

@@ -73,6 +73,7 @@ def update_current_trace(
     tools_called: Optional[List[ToolCall]] = None,
     expected_tools: Optional[List[ToolCall]] = None,
     test_case: Optional[LLMTestCase] = None,
+    confident_api_key: Optional[str] = None,
 ):
     current_trace = current_trace_context.get()
     if not current_trace:
@@ -109,6 +110,8 @@ def update_current_trace(
         current_trace.tools_called = tools_called
     if expected_tools:
         current_trace.expected_tools = expected_tools
+    if confident_api_key:
+        current_trace.confident_api_key = confident_api_key
 
 
 def update_llm_span(

deepeval/tracing/tracing.py

@@ -441,11 +441,11 @@ class TraceManager:
         loop = asyncio.new_event_loop()
         asyncio.set_event_loop(loop)
 
-        # buffer for payloads that need to be sent after main exits
-        remaining_trace_request_bodies: List[Dict[str, Any]] = []
+        # buffer for traces that need to be sent after main exits
+        remaining_traces: List[TraceApi] = []
 
         async def _a_send_trace(trace_obj):
-            nonlocal remaining_trace_request_bodies
+            nonlocal remaining_traces
             try:
                 # Build API object & payload
                 if isinstance(trace_obj, TraceApi):
@@ -486,7 +486,7 @@ class TraceManager:
                     )
                 elif self._flush_enabled:
                     # Main thread gone → to be flushed
-                    remaining_trace_request_bodies.append(body)
+                    remaining_traces.append(trace_api)
 
             except Exception as e:
                 queue_size = self._trace_queue.qsize()
@@ -544,24 +544,35 @@ class TraceManager:
                 loop.run_until_complete(
                     asyncio.gather(*pending, return_exceptions=True)
                 )
-            self.flush_traces(remaining_trace_request_bodies)
+            self.flush_traces(remaining_traces)
             loop.run_until_complete(loop.shutdown_asyncgens())
             loop.close()
 
-    def flush_traces(
-        self, remaining_trace_request_bodies: List[Dict[str, Any]]
-    ):
+    def flush_traces(self, remaining_traces: List[TraceApi]):
         if not tracing_enabled() or not self.tracing_enabled:
             return
 
         self._print_trace_status(
             TraceWorkerStatus.WARNING,
-            message=f"Flushing {len(remaining_trace_request_bodies)} remaining trace(s)",
+            message=f"Flushing {len(remaining_traces)} remaining trace(s)",
         )
-        for body in remaining_trace_request_bodies:
+        for trace_api in remaining_traces:
             with capture_send_trace():
                 try:
-                    api = Api(api_key=self.confident_api_key)
+                    try:
+                        body = trace_api.model_dump(
+                            by_alias=True,
+                            exclude_none=True,
+                        )
+                    except AttributeError:
+                        # Pydantic version below 2.0
+                        body = trace_api.dict(by_alias=True, exclude_none=True)
+
+                    body = make_json_serializable(body)
+                    if trace_api.confident_api_key:
+                        api = Api(api_key=trace_api.confident_api_key)
+                    else:
+                        api = Api(api_key=self.confident_api_key)
 
                     _, link = api.send_request(
                         method=HttpMethods.POST,

{deepeval-3.7.2.dist-info → deepeval-3.7.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: deepeval
-Version: 3.7.2
+Version: 3.7.3
 Summary: The LLM Evaluation Framework
 Home-page: https://github.com/confident-ai/deepeval
 License: Apache-2.0

{deepeval-3.7.2.dist-info → deepeval-3.7.3.dist-info}/RECORD

@@ -1,5 +1,5 @@
 deepeval/__init__.py,sha256=tle4lT4FONApg3OeztGPEdrpGMEGLWajyGTu7bEd3s0,2976
-deepeval/_version.py,sha256=uv4OEocrxlEkjp4YMUEXl0-kwRJuwkdtGlNshton0Mg,27
+deepeval/_version.py,sha256=neKNug0TPAnGHtzNXdePXNla9tw6mxKTmj9WJu2trY8,27
 deepeval/annotation/__init__.py,sha256=ZFhUVNNuH_YgQSZJ-m5E9iUb9TkAkEV33a6ouMDZ8EI,111
 deepeval/annotation/annotation.py,sha256=3j3-syeJepAcEj3u3e4T_BeRDzNr7yXGDIoNQGMKpwQ,2298
 deepeval/annotation/api.py,sha256=EYN33ACVzVxsFleRYm60KB4Exvff3rPJKt1VBuuX970,2147
@@ -96,7 +96,7 @@ deepeval/benchmarks/hellaswag/hellaswag.py,sha256=_3felzBwQUhhRXk4D9NbcY8dme_qUQ
 deepeval/benchmarks/hellaswag/task.py,sha256=LfO8T6bpNiwdM8VdubKrup7qje3-rHgu69iB6Sdsc6I,7323
 deepeval/benchmarks/hellaswag/template.py,sha256=TcCu25hkl89qbRwcEyRVGTGp7DU_5Eph754W2znk5QY,1279
 deepeval/benchmarks/human_eval/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-deepeval/benchmarks/human_eval/human_eval.py,sha256=cx4x5OAeCrTjuUdQI7gjeSY_pUL3crfzKmieL1yKXMY,7714
+deepeval/benchmarks/human_eval/human_eval.py,sha256=1xMVLQ1rQccY9Ac7BB6_1dFjo1QLK7DEMg0QXY2ybRM,7756
 deepeval/benchmarks/human_eval/task.py,sha256=lEHJpEiRbw5cXUKA_id0J5gQwae1G1T1JCJAeeTpXGg,5412
 deepeval/benchmarks/human_eval/template.py,sha256=rcCHSb0wP_FS9DQPaoBn-iwgicI1OyEdFCkZLQ1vxPk,647
 deepeval/benchmarks/ifeval/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
@@ -153,11 +153,11 @@ deepeval/constants.py,sha256=J5rNXGsMKTFYJ_9Wi49qchZXuUityZjnvuy3I3TO5zk,1667
 deepeval/contextvars.py,sha256=oqXtuYiKd4Zvc1rNoR1gcRBxzZYCGTMVn7XostwvkRI,524
 deepeval/dataset/__init__.py,sha256=N2c-rkuxWYiiJSOZArw0H02Cwo7cnfzFuNYJlvsIBEg,249
 deepeval/dataset/api.py,sha256=ZxkEqAF4nZH_Ys_1f5r9N2LFI_vBcAJxt8eJm7Mplpw,831
-deepeval/dataset/dataset.py,sha256=Nx0Nr12_AGjOOOmmAMaC6YIX62HgK8T86FtcL9IrsF4,57798
+deepeval/dataset/dataset.py,sha256=Y9U-hVoa5BbnlzwJiFiDTkDcp9E6VmKOd7NtyLmdpHY,59182
 deepeval/dataset/golden.py,sha256=T-rTk4Hw1tANx_Iimv977F6Y4QK3s5OIB4PecU5FJDM,2338
 deepeval/dataset/test_run_tracer.py,sha256=5CdpDvhzkEEBRyqWi6egocaxiN6IRS3XfbACxEQZQeM,2544
 deepeval/dataset/types.py,sha256=CWeOIBPK2WdmRUqjFa9gfN-w2da0r8Ilzl3ToDpJQoQ,558
-deepeval/dataset/utils.py,sha256=MRiqwt-3E5WNCHtP2kY7P1PeRtFMRpGoy3r75tJ2QFg,7910
+deepeval/dataset/utils.py,sha256=nWCNmD1kyLwvlCXlN-7XiqN2W7IUOkDckc1xl32MF-U,8042
 deepeval/errors.py,sha256=FfhtULNIQqHpKVqCr-xlvTtLxkNj40qVU89sXYKuDrA,754
 deepeval/evaluate/__init__.py,sha256=315IaMiYEz7oJhZ4kPTBfeCNd1xF-wWVU6KOQnrKQpE,291
 deepeval/evaluate/api.py,sha256=rkblH0ZFAAdyuF0Ymh7JE1pIJPR9yFuPrn9SQaCEQp4,435
@@ -394,11 +394,11 @@ deepeval/metrics/turn_relevancy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm
 deepeval/metrics/turn_relevancy/schema.py,sha256=om0zFJcM6qu2GWS9aJTP3lUmuEXX8KpoACEvCsJqfq4,234
 deepeval/metrics/turn_relevancy/template.py,sha256=klZ10QI8jo4ekf-KgcWgRxS9E3AK4vgKDNzjwAYGl48,2797
 deepeval/metrics/turn_relevancy/turn_relevancy.py,sha256=cgMt0toBIwzDc8lE8Q3YztzQA_DqR4GfdDrlyX7ya6w,10385
-deepeval/metrics/utils.py,sha256=iSzb8mOpqT5Ciceix761zjlDUm0eMU-L4V6PyetIIeg,18778
+deepeval/metrics/utils.py,sha256=gEEETXaug997fqrVW2Suceuaw1MgZAYMF4wT15Mu2Z8,18920
 deepeval/model_integrations/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 deepeval/model_integrations/types.py,sha256=rbVMhC_2yWwD6JqzkRO9D7aMVC_KtXN686G_S7de7S8,630
 deepeval/model_integrations/utils.py,sha256=Zt9SYPgTxlGsQFZgpZvh_a5fWuL8mmIFVSe6uoQywZ4,3562
-deepeval/models/__init__.py,sha256=0x4EsoqtSf7sLOg28DoOoInL_D5fKPWCakkE2gJa2pM,1195
+deepeval/models/__init__.py,sha256=7vANBeNkDUADNzP8cyZUoQVmExEEODlHWGcj_9ik9A8,1269
 deepeval/models/_summac_model.py,sha256=xflanxl_IBuzuainlYCVX7UvjHCnAckKSvNR2NwZI6k,19750
 deepeval/models/answer_relevancy_model.py,sha256=SLOA6uUImNOuxpPGfTg2AH7MIkf9QsotYixvI1jcVC8,2197
 deepeval/models/base_model.py,sha256=owmHhVBppPe5Zt6GK9p87dE31hoqtn5_8F9TWr97aRE,4112
@@ -422,7 +422,8 @@ deepeval/models/llms/local_model.py,sha256=hEyKVA6pkQm9dICUKsMNgjVI3w6gnyMdmBt_E
 deepeval/models/llms/ollama_model.py,sha256=xPO4d4jMY-cQAyHAcMuFvWS8JMWwCUbKP9CMi838Nuc,3307
 deepeval/models/llms/openai_model.py,sha256=1rjwbyt87fK03pw7r5tq3PjUVfl2EWllAssGyy6Dt2A,17494
 deepeval/models/llms/utils.py,sha256=gFM_8eIvdSwN_D4Yqp-j7PkfoiRn_bgu7tlCHol3A6c,1324
-deepeval/models/mlllms/__init__.py,sha256=19nN6kUB5XI0nUWUQX0aD9GBUMM8WWGvsDgKjuT4EF4,144
+deepeval/models/mlllms/__init__.py,sha256=EgFWQcqVPhIqb90QCtIH2Np0bLSRj_beaymbuRN7Ds8,200
+deepeval/models/mlllms/azure_model.py,sha256=pMpLAKZypVKMOAtyHToX8WgCcbbA8hXa2sd16DhCKEM,12696
 deepeval/models/mlllms/gemini_model.py,sha256=7tHIWD4w_fBz3L7jkKWygn1QpBPk9nl2Kw-yb0Jc3PI,10167
 deepeval/models/mlllms/ollama_model.py,sha256=_YtYtw8oIMVVI-CFsDicsdeEJUPhw_9ArPxB_1olsJA,4798
 deepeval/models/mlllms/openai_model.py,sha256=KgvYgQwWZ1A_Gcl6-4-W7IMqbUF9K8sNY37j5Ag7kQQ,9014
@@ -487,7 +488,7 @@ deepeval/test_run/hyperparameters.py,sha256=4yJkNgwL2y6eyWDTmUV62f5RUlfOui4R22ws
 deepeval/test_run/test_run.py,sha256=mStiBQZkgktwF99FRqkT_-UFrMT0m06X20TEEO6V2Bc,41278
 deepeval/tracing/__init__.py,sha256=aSOk_ZgL-K7CZzcyiaIa5peAiaPViDST5GhpHA3Adc8,614
 deepeval/tracing/api.py,sha256=GbtpUDdGpchl6rPXtZT6IBKjAhwux6qOlKLdP3dRVHU,4996
-deepeval/tracing/context.py,sha256=rzm42zYzP7jmQJO08AV-Qmw86ik45qRfF4UQNpGcmJw,5338
+deepeval/tracing/context.py,sha256=v4uzd0N2H8mNntPwZvL49ya2kW9FvjqQqWXJFgE5d0c,5469
 deepeval/tracing/offline_evals/__init__.py,sha256=bEniJAl7PmS9u2ksiOTfHtlCPJ9_CJV5R6umrUOX5MM,102
 deepeval/tracing/offline_evals/api.py,sha256=eBfqh2uWyeRkIeGhjrN1bTQzAEow-XPubs-42WEZ2QQ,510
 deepeval/tracing/offline_evals/span.py,sha256=pXqTVXs-WnjRVpCYYEbNe0zSM6Wz9GsKHsM5ZcWxrmM,1802
@@ -501,12 +502,12 @@ deepeval/tracing/patchers.py,sha256=c-8Fjc5VIWB5VD9ONKq735ypW6O1pZIFQWsHR3lRh0E,
 deepeval/tracing/perf_epoch_bridge.py,sha256=iyAPddB6Op7NpMtPHJ29lDm53Btz9yLaN6xSCfTRQm4,1825
 deepeval/tracing/trace_context.py,sha256=Z0n0Cu1A5g9dXiZnzTFO5TzeOYHKeNuO6v3_EU_Gi_c,3568
 deepeval/tracing/trace_test_manager.py,sha256=wt4y7EWTRc4Bw938-UFFtXHkdFFOrnx6JaIk7J5Iulw,555
-deepeval/tracing/tracing.py,sha256=VWu5z6fxWP6KfDaw5ZmIkN-0yNDqe1CVHa0e9_Wjrgg,45995
+deepeval/tracing/tracing.py,sha256=dx4JpiixkscEaYBR0LFpYCjeGgfZqiVlRCD-HblMo6g,46459
 deepeval/tracing/types.py,sha256=WhnxefUc5I8jcAOBQ-tsZ8_zVZfGqSvCWHD5XUN6Ggw,6040
 deepeval/tracing/utils.py,sha256=mdvhYAxDNsdnusaEXJd-c-_O2Jn6S3xSuzRvLO1Jz4U,5684
 deepeval/utils.py,sha256=zy9RR0bt3YMzWVlJc5Rl6eU5RyeW2uEjMfwD1sdgPr4,23234
-deepeval-3.7.2.dist-info/LICENSE.md,sha256=0ATkuLv6QgsJTBODUHC5Rak_PArA6gv2t7inJzNTP38,11352
-deepeval-3.7.2.dist-info/METADATA,sha256=-p5kW-oBcfsEi5_uiLnCn_godaoKAeRDCgzRdpOsWUI,18743
-deepeval-3.7.2.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
-deepeval-3.7.2.dist-info/entry_points.txt,sha256=fVr8UphXTfJe9I2rObmUtfU3gkSrYeM0pLy-NbJYg10,94
-deepeval-3.7.2.dist-info/RECORD,,
+deepeval-3.7.3.dist-info/LICENSE.md,sha256=0ATkuLv6QgsJTBODUHC5Rak_PArA6gv2t7inJzNTP38,11352
+deepeval-3.7.3.dist-info/METADATA,sha256=LvW_cE214Ta8lMgI-eQC3cnlO0c6yHyYw1L4B4AHxaM,18743
+deepeval-3.7.3.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+deepeval-3.7.3.dist-info/entry_points.txt,sha256=NoismUQfwLOojSGZmBrdcpwfaoFRAzUhBvZD3UwOKog,95
+deepeval-3.7.3.dist-info/RECORD,,

{deepeval-3.7.2.dist-info → deepeval-3.7.3.dist-info}/entry_points.txt

@@ -2,5 +2,5 @@
 deepeval=deepeval.cli.main:app
 
 [pytest11]
-plugins=deepeval.plugins.plugin
+deepeval=deepeval.plugins.plugin