deepeval 3.4.3__tar.gz → 3.4.5__tar.gz

{deepeval-3.4.3 → deepeval-3.4.5}/PKG-INFO

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

deepeval-3.4.5/deepeval/_version.py

@@ -0,0 +1 @@
+__version__: str = "3.4.5"

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/benchmarks/equity_med_qa/equity_med_qa.py

@@ -119,7 +119,8 @@ class EquityMedQA(DeepEvalBaseBenchmark):
             strict_mode=True,
         )
         score = metric.measure(
-            LLMTestCase(golden.input, prediction), _show_indicator=False
+            LLMTestCase(input=golden.input, actual_output=prediction),
+            _show_indicator=False,
         )
         flipped_score = (
             1 - metric.score if metric.score in [0, 1] else metric.score

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/confident/api.py

@@ -67,8 +67,8 @@ class HttpMethods(Enum):
 
 
 class Endpoints(Enum):
-    DATASET_ENDPOINT = "/v1/datasets"
-    DATASET_QUEUE_ENDPOINT = "/v1/datasets/:alias/queue"
+    DATASET_ALIAS_ENDPOINT = "/v1/datasets/:alias"
+    DATASET_ALIAS_QUEUE_ENDPOINT = "/v1/datasets/:alias/queue"
 
     TEST_RUN_ENDPOINT = "/v1/test-run"
     TRACES_ENDPOINT = "/v1/traces"

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/dataset/api.py

@@ -5,8 +5,7 @@ from deepeval.dataset.golden import Golden, ConversationalGolden
 
 
 class APIDataset(BaseModel):
-    alias: str
-    overwrite: bool
+    finalized: bool
     goldens: Optional[List[Golden]] = Field(None)
     conversational_goldens: Optional[List[ConversationalGolden]] = Field(
         None, alias="conversationalGoldens"

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/dataset/dataset.py

@@ -46,6 +46,7 @@ from deepeval.test_run import (
 )
 from deepeval.dataset.types import global_evaluation_tasks
 from deepeval.openai.utils import openai_test_case_pairs
+from deepeval.tracing import trace_manager
 
 
 valid_file_types = ["csv", "json", "jsonl"]
@@ -656,7 +657,7 @@ class EvaluationDataset:
     def push(
         self,
         alias: str,
-        overwrite: bool = False,
+        finalized: bool = True,
     ):
         if len(self.goldens) == 0:
             raise ValueError(
@@ -665,10 +666,9 @@ class EvaluationDataset:
 
         api = Api()
         api_dataset = APIDataset(
-            alias=alias,
-            overwrite=overwrite,
             goldens=self.goldens if not self._multi_turn else None,
             conversationalGoldens=(self.goldens if self._multi_turn else None),
+            finalized=finalized,
         )
         try:
             body = api_dataset.model_dump(by_alias=True, exclude_none=True)
@@ -678,8 +678,9 @@ class EvaluationDataset:
 
         _, link = api.send_request(
             method=HttpMethods.POST,
-            endpoint=Endpoints.DATASET_ENDPOINT,
+            endpoint=Endpoints.DATASET_ALIAS_ENDPOINT,
             body=body,
+            url_params={"alias": alias},
         )
         if link:
             console = Console()
@@ -711,9 +712,9 @@ class EvaluationDataset:
                 start_time = time.perf_counter()
                 data, _ = api.send_request(
                     method=HttpMethods.GET,
-                    endpoint=Endpoints.DATASET_ENDPOINT,
+                    endpoint=Endpoints.DATASET_ALIAS_ENDPOINT,
+                    url_params={"alias": alias},
                     params={
-                        "alias": alias,
                         "finalized": str(finalized).lower(),
                         "public": str(public).lower(),
                     },
@@ -797,7 +798,7 @@ class EvaluationDataset:
 
         _, link = api.send_request(
             method=HttpMethods.POST,
-            endpoint=Endpoints.DATASET_QUEUE_ENDPOINT,
+            endpoint=Endpoints.DATASET_ALIAS_QUEUE_ENDPOINT,
             body=body,
             url_params={"alias": alias},
         )
@@ -808,6 +809,19 @@ class EvaluationDataset:
                 f"[link={link}]{link}[/link]"
             )
 
+    def delete(
+        self,
+        alias: str,
+    ):
+        api = Api()
+        api.send_request(
+            method=HttpMethods.DELETE,
+            endpoint=Endpoints.DATASET_ALIAS_ENDPOINT,
+            url_params={"alias": alias},
+        )
+        console = Console()
+        console.print("✅ Dataset successfully deleted from Confident AI!")
+
     def generate_goldens_from_docs(
         self,
         document_paths: List[str],
@@ -1112,7 +1126,7 @@ class EvaluationDataset:
 
         if not self.goldens or len(self.goldens) == 0:
             raise ValueError("Unable to evaluate dataset with no goldens.")
-
+        trace_manager.integration_traces_to_evaluate.clear()
         goldens = self.goldens
         with capture_evaluation_run("traceable evaluate()"):
             global_test_run_manager.reset()

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/simulator/conversation_simulator.py

@@ -1,7 +1,6 @@
 from typing import Optional, List, Union, Callable
 from rich.progress import Progress
 from pydantic import BaseModel
-from dataclasses import asdict
 import inspect
 import asyncio
 import uuid
@@ -465,7 +464,7 @@ class ConversationSimulator:
     ):
         if not self.run_remote:
             conversation_history = json.dumps(
-                [asdict(t) for t in turns], indent=4
+                [t.model_dump() for t in turns], indent=4
             )
             prompt = self.template.stop_simulation(
                 conversation_history, golden.expected_outcome
@@ -510,7 +509,7 @@ class ConversationSimulator:
     ):
         if not self.run_remote:
             conversation_history = json.dumps(
-                [asdict(t) for t in turns], indent=4
+                [t.model_dump() for t in turns], indent=4
             )
             prompt = self.template.stop_simulation(
                 conversation_history, golden.expected_outcome

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/simulator/template.py

@@ -1,4 +1,3 @@
-from dataclasses import asdict
 from typing import List
 import textwrap
 import json
@@ -48,7 +47,9 @@ class ConversationSimulatorTemplate:
         turns: List[Turn],
         language: str,
     ) -> str:
-        previous_conversation = json.dumps([asdict(t) for t in turns], indent=4)
+        previous_conversation = json.dumps(
+            [t.model_dump() for t in turns], indent=4
+        )
         prompt = textwrap.dedent(
             f"""
             Pretend you are a user of an LLM app. Your task is to generate the next user input in {language} 

deepeval-3.4.5/deepeval/test_case/conversational_test_case.py

@@ -0,0 +1,192 @@
+from pydantic import (
+    BaseModel,
+    Field,
+    PrivateAttr,
+    model_validator,
+    AliasChoices,
+)
+from typing import List, Optional, Dict, Literal
+from copy import deepcopy
+from enum import Enum
+
+from deepeval.test_case import ToolCall
+from deepeval.test_case.mcp import (
+    MCPServer,
+    MCPPromptCall,
+    MCPResourceCall,
+    MCPToolCall,
+    validate_mcp_servers,
+)
+
+
+class TurnParams(Enum):
+    ROLE = "role"
+    CONTENT = "content"
+    SCENARIO = "scenario"
+    EXPECTED_OUTCOME = "expected_outcome"
+    RETRIEVAL_CONTEXT = "retrieval_context"
+    TOOLS_CALLED = "tools_called"
+    MCP_TOOLS = "mcp_tools_called"
+    MCP_RESOURCES = "mcp_resources_called"
+    MCP_PROMPTS = "mcp_prompts_called"
+
+
+class Turn(BaseModel):
+    role: Literal["user", "assistant"]
+    content: str
+    user_id: Optional[str] = Field(
+        default=None, validation_alias=AliasChoices("userId", "user_id")
+    )
+    retrieval_context: Optional[List[str]] = Field(
+        default=None,
+        validation_alias=AliasChoices("retrievalContext", "retrieval_context"),
+    )
+    tools_called: Optional[List[ToolCall]] = Field(
+        default=None,
+        validation_alias=AliasChoices("toolsCalled", "tools_called"),
+    )
+    mcp_tools_called: Optional[List[MCPToolCall]] = Field(default=None)
+    mcp_resources_called: Optional[List[MCPResourceCall]] = Field(default=None)
+    mcp_prompts_called: Optional[List[MCPPromptCall]] = Field(default=None)
+    additional_metadata: Optional[Dict] = Field(
+        default=None,
+        serialization_alias="additionalMetadata",
+        validation_alias=AliasChoices(
+            "additionalMetadata", "additional_metadata"
+        ),
+    )
+    _mcp_interaction: bool = PrivateAttr(default=False)
+
+    def __repr__(self):
+        attrs = [f"role={self.role!r}", f"content={self.content!r}"]
+        if self.user_id is not None:
+            attrs.append(f"user_id={self.user_id!r}")
+        if self.retrieval_context is not None:
+            attrs.append(f"retrieval_context={self.retrieval_context!r}")
+        if self.tools_called is not None:
+            attrs.append(f"tools_called={self.tools_called!r}")
+        if self.mcp_tools_called is not None:
+            attrs.append(f"mcp_tools_called={self.mcp_tools_called!r}")
+        if self.mcp_resources_called is not None:
+            attrs.append(f"mcp_resources_called={self.mcp_resources_called!r}")
+        if self.mcp_prompts_called is not None:
+            attrs.append(f"mcp_prompts_called={self.mcp_prompts_called!r}")
+        if self.additional_metadata is not None:
+            attrs.append(f"additional_metadata={self.additional_metadata!r}")
+        return f"Turn({', '.join(attrs)})"
+
+    @model_validator(mode="before")
+    def validate_input(cls, data):
+        mcp_tools_called = data.get("mcp_tools_called")
+        mcp_prompts_called = data.get("mcp_prompts_called")
+        mcp_resources_called = data.get("mcp_resources_called")
+
+        if (
+            mcp_tools_called is not None
+            or mcp_prompts_called is not None
+            or mcp_resources_called is not None
+        ):
+            from mcp.types import (
+                CallToolResult,
+                ReadResourceResult,
+                GetPromptResult,
+            )
+
+            data["_mcp_interaction"] = True
+            if mcp_tools_called is not None:
+                if not isinstance(mcp_tools_called, list) or not all(
+                    isinstance(tool_called, MCPToolCall)
+                    and isinstance(tool_called.result, CallToolResult)
+                    for tool_called in mcp_tools_called
+                ):
+                    raise TypeError(
+                        "The 'tools_called' must be a list of 'MCPToolCall' with result of type 'CallToolResult' from mcp.types"
+                    )
+
+            if mcp_resources_called is not None:
+                if not isinstance(mcp_resources_called, list) or not all(
+                    isinstance(resource_called, MCPResourceCall)
+                    and isinstance(resource_called.result, ReadResourceResult)
+                    for resource_called in mcp_resources_called
+                ):
+                    raise TypeError(
+                        "The 'resources_called' must be a list of 'MCPResourceCall' with result of type 'ReadResourceResult' from mcp.types"
+                    )
+
+            if mcp_prompts_called is not None:
+                if not isinstance(mcp_prompts_called, list) or not all(
+                    isinstance(prompt_called, MCPPromptCall)
+                    and isinstance(prompt_called.result, GetPromptResult)
+                    for prompt_called in mcp_prompts_called
+                ):
+                    raise TypeError(
+                        "The 'prompts_called' must be a list of 'MCPPromptCall' with result of type 'GetPromptResult' from mcp.types"
+                    )
+
+        return data
+
+
+class ConversationalTestCase(BaseModel):
+    turns: List[Turn]
+    scenario: Optional[str] = Field(default=None)
+    context: Optional[List[str]] = Field(default=None)
+    name: Optional[str] = Field(default=None)
+    user_description: Optional[str] = Field(
+        default=None,
+        serialization_alias="userDescription",
+        validation_alias=AliasChoices("userDescription", "user_description"),
+    )
+    expected_outcome: Optional[str] = Field(
+        default=None,
+        serialization_alias="expectedOutcome",
+        validation_alias=AliasChoices("expectedOutcome", "expected_outcome"),
+    )
+    chatbot_role: Optional[str] = Field(
+        default=None,
+        serialization_alias="chatbotRole",
+        validation_alias=AliasChoices("chatbotRole", "chatbot_role"),
+    )
+    additional_metadata: Optional[Dict] = Field(
+        default=None,
+        serialization_alias="additionalMetadata",
+        validation_alias=AliasChoices(
+            "additionalMetadata", "additional_metadata"
+        ),
+    )
+    comments: Optional[str] = Field(default=None)
+    tags: Optional[List[str]] = Field(default=None)
+    mcp_servers: Optional[List[MCPServer]] = Field(default=None)
+
+    _dataset_rank: Optional[int] = PrivateAttr(default=None)
+    _dataset_alias: Optional[str] = PrivateAttr(default=None)
+    _dataset_id: Optional[str] = PrivateAttr(default=None)
+
+    @model_validator(mode="before")
+    def validate_input(cls, data):
+        turns = data.get("turns")
+        context = data.get("context")
+        mcp_servers = data.get("mcp_servers")
+
+        if len(turns) == 0:
+            raise TypeError("'turns' must not be empty")
+
+        # Ensure `context` is None or a list of strings
+        if context is not None:
+            if not isinstance(context, list) or not all(
+                isinstance(item, str) for item in context
+            ):
+                raise TypeError("'context' must be None or a list of strings")
+
+        if mcp_servers is not None:
+            validate_mcp_servers(mcp_servers)
+
+        copied_turns = []
+        for turn in turns:
+            if not isinstance(turn, Turn):
+                raise TypeError("'turns' must be a list of `Turn`s")
+
+            copied_turns.append(deepcopy(turn))
+
+        data["turns"] = copied_turns
+
+        return data

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/test_case/llm_test_case.py

@@ -1,5 +1,10 @@
-from pydantic import Field, BaseModel
-from dataclasses import dataclass, field
+from pydantic import (
+    Field,
+    BaseModel,
+    model_validator,
+    PrivateAttr,
+    AliasChoices,
+)
 from typing import List, Optional, Dict, Any
 from enum import Enum
 import json
@@ -68,7 +73,9 @@ class ToolCall(BaseModel):
     reasoning: Optional[str] = None
     output: Optional[Any] = None
     input_parameters: Optional[Dict[str, Any]] = Field(
-        None, serialization_alias="inputParameters"
+        None,
+        serialization_alias="inputParameters",
+        validation_alias=AliasChoices("inputParameters", "input_parameters"),
     )
 
     def __eq__(self, other):
@@ -143,120 +150,180 @@ class ToolCall(BaseModel):
         )
 
 
-@dataclass
-class LLMTestCase:
+class LLMTestCase(BaseModel):
     input: str
-    actual_output: Optional[str] = None
-    expected_output: Optional[str] = None
-    context: Optional[List[str]] = None
-    retrieval_context: Optional[List[str]] = None
-    additional_metadata: Optional[Dict] = None
-    tools_called: Optional[List[ToolCall]] = None
-    comments: Optional[str] = None
-    expected_tools: Optional[List[ToolCall]] = None
-    token_cost: Optional[float] = None
-    completion_time: Optional[float] = None
-    name: Optional[str] = field(default=None)
-    tags: Optional[List[str]] = field(default=None)
-    mcp_servers: Optional[List[MCPServer]] = None
-    mcp_tools_called: Optional[List[MCPToolCall]] = None
-    mcp_resources_called: Optional[List[MCPResourceCall]] = None
-    mcp_prompts_called: Optional[List[MCPPromptCall]] = None
-    _trace_dict: Optional[Dict] = field(default=None, repr=False)
-    _dataset_rank: Optional[int] = field(default=None, repr=False)
-    _dataset_alias: Optional[str] = field(default=None, repr=False)
-    _dataset_id: Optional[str] = field(default=None, repr=False)
-    _identifier: Optional[str] = field(default=str(uuid.uuid4()), repr=False)
-
-    def __post_init__(self):
-        if self.input is not None:
-            if not isinstance(self.input, str):
+    actual_output: Optional[str] = Field(
+        default=None,
+        serialization_alias="actualOutput",
+        validation_alias=AliasChoices("actualOutput", "actual_output"),
+    )
+    expected_output: Optional[str] = Field(
+        default=None,
+        serialization_alias="expectedOutput",
+        validation_alias=AliasChoices("expectedOutput", "expected_output"),
+    )
+    context: Optional[List[str]] = Field(
+        default=None, serialization_alias="context"
+    )
+    retrieval_context: Optional[List[str]] = Field(
+        default=None,
+        serialization_alias="retrievalContext",
+        validation_alias=AliasChoices("retrievalContext", "retrieval_context"),
+    )
+    additional_metadata: Optional[Dict] = Field(
+        default=None,
+        serialization_alias="additionalMetadata",
+        validation_alias=AliasChoices(
+            "additionalMetadata", "additional_metadata"
+        ),
+    )
+    tools_called: Optional[List[ToolCall]] = Field(
+        default=None,
+        serialization_alias="toolsCalled",
+        validation_alias=AliasChoices("toolsCalled", "tools_called"),
+    )
+    comments: Optional[str] = Field(
+        default=None, serialization_alias="comments"
+    )
+    expected_tools: Optional[List[ToolCall]] = Field(
+        default=None,
+        serialization_alias="expectedTools",
+        validation_alias=AliasChoices("expectedTools", "expected_tools"),
+    )
+    token_cost: Optional[float] = Field(
+        default=None,
+        serialization_alias="tokenCost",
+        validation_alias=AliasChoices("tokenCost", "token_cost"),
+    )
+    completion_time: Optional[float] = Field(
+        default=None,
+        serialization_alias="completionTime",
+        validation_alias=AliasChoices("completionTime", "completion_time"),
+    )
+    name: Optional[str] = Field(default=None)
+    tags: Optional[List[str]] = Field(default=None)
+    mcp_servers: Optional[List[MCPServer]] = Field(default=None)
+    mcp_tools_called: Optional[List[MCPToolCall]] = Field(
+        default=None,
+        serialization_alias="mcpToolsCalled",
+    )
+    mcp_resources_called: Optional[List[MCPResourceCall]] = Field(
+        default=None, serialization_alias="mcpResourcesCalled"
+    )
+    mcp_prompts_called: Optional[List[MCPPromptCall]] = Field(
+        default=None, serialization_alias="mcpPromptsCalled"
+    )
+    _trace_dict: Optional[Dict] = PrivateAttr(default=None)
+    _dataset_rank: Optional[int] = PrivateAttr(default=None)
+    _dataset_alias: Optional[str] = PrivateAttr(default=None)
+    _dataset_id: Optional[str] = PrivateAttr(default=None)
+    _identifier: Optional[str] = PrivateAttr(
+        default_factory=lambda: str(uuid.uuid4())
+    )
+
+    @model_validator(mode="before")
+    def validate_input(cls, data):
+        input = data.get("input")
+        actual_output = data.get("actual_output")
+        context = data.get("context")
+        retrieval_context = data.get("retrieval_context")
+        tools_called = data.get("tools_called")
+        expected_tools = data.get("expected_tools")
+        mcp_servers = data.get("mcp_servers")
+        mcp_tools_called = data.get("mcp_tools_called")
+        mcp_resources_called = data.get("mcp_resources_called")
+        mcp_prompts_called = data.get("mcp_prompts_called")
+
+        if input is not None:
+            if not isinstance(input, str):
                 raise TypeError("'input' must be a string")
 
-        if self.actual_output is not None:
-            if not isinstance(self.actual_output, str):
+        if actual_output is not None:
+            if not isinstance(actual_output, str):
                 raise TypeError("'actual_output' must be a string")
 
         # Ensure `context` is None or a list of strings
-        if self.context is not None:
-            if not isinstance(self.context, list) or not all(
-                isinstance(item, str) for item in self.context
+        if context is not None:
+            if not isinstance(context, list) or not all(
+                isinstance(item, str) for item in context
             ):
                 raise TypeError("'context' must be None or a list of strings")
 
         # Ensure `retrieval_context` is None or a list of strings
-        if self.retrieval_context is not None:
-            if not isinstance(self.retrieval_context, list) or not all(
-                isinstance(item, str) for item in self.retrieval_context
+        if retrieval_context is not None:
+            if not isinstance(retrieval_context, list) or not all(
+                isinstance(item, str) for item in retrieval_context
             ):
                 raise TypeError(
                     "'retrieval_context' must be None or a list of strings"
                 )
 
         # Ensure `tools_called` is None or a list of strings
-        if self.tools_called is not None:
-            if not isinstance(self.tools_called, list) or not all(
-                isinstance(item, ToolCall) for item in self.tools_called
+        if tools_called is not None:
+            if not isinstance(tools_called, list) or not all(
+                isinstance(item, ToolCall) for item in tools_called
             ):
                 raise TypeError(
                     "'tools_called' must be None or a list of `ToolCall`"
                 )
 
         # Ensure `expected_tools` is None or a list of strings
-        if self.expected_tools is not None:
-            if not isinstance(self.expected_tools, list) or not all(
-                isinstance(item, ToolCall) for item in self.expected_tools
+        if expected_tools is not None:
+            if not isinstance(expected_tools, list) or not all(
+                isinstance(item, ToolCall) for item in expected_tools
             ):
                 raise TypeError(
                     "'expected_tools' must be None or a list of `ToolCall`"
                 )
 
         # Ensure `mcp_server` is None or a list of `MCPServer`
-        if self.mcp_servers is not None:
-            if not isinstance(self.mcp_servers, list) or not all(
-                isinstance(item, MCPServer) for item in self.mcp_servers
+        if mcp_servers is not None:
+            if not isinstance(mcp_servers, list) or not all(
+                isinstance(item, MCPServer) for item in mcp_servers
             ):
                 raise TypeError(
                     "'mcp_server' must be None or a list of 'MCPServer'"
                 )
             else:
-                validate_mcp_servers(self.mcp_servers)
+                validate_mcp_servers(mcp_servers)
 
         # Ensure `mcp_tools_called` is None or a list of `MCPToolCall`
-        if self.mcp_tools_called is not None:
+        if mcp_tools_called is not None:
             from mcp.types import CallToolResult
 
-            if not isinstance(self.mcp_tools_called, list) or not all(
+            if not isinstance(mcp_tools_called, list) or not all(
                 isinstance(tool_called, MCPToolCall)
                 and isinstance(tool_called.result, CallToolResult)
-                for tool_called in self.mcp_tools_called
+                for tool_called in mcp_tools_called
             ):
                 raise TypeError(
                     "The 'tools_called' must be a list of 'MCPToolCall' with result of type 'CallToolResult' from mcp.types"
                 )
 
         # Ensure `mcp_resources_called` is None or a list of `MCPResourceCall`
-        if self.mcp_resources_called is not None:
+        if mcp_resources_called is not None:
             from mcp.types import ReadResourceResult
 
-            if not isinstance(self.mcp_resources_called, list) or not all(
+            if not isinstance(mcp_resources_called, list) or not all(
                 isinstance(resource_called, MCPResourceCall)
                 and isinstance(resource_called.result, ReadResourceResult)
-                for resource_called in self.mcp_resources_called
+                for resource_called in mcp_resources_called
             ):
                 raise TypeError(
                     "The 'resources_called' must be a list of 'MCPResourceCall' with result of type 'ReadResourceResult' from mcp.types"
                 )
 
         # Ensure `mcp_prompts_called` is None or a list of `MCPPromptCall`
-        if self.mcp_prompts_called is not None:
+        if mcp_prompts_called is not None:
             from mcp.types import GetPromptResult
 
-            if not isinstance(self.mcp_prompts_called, list) or not all(
+            if not isinstance(mcp_prompts_called, list) or not all(
                 isinstance(prompt_called, MCPPromptCall)
                 and isinstance(prompt_called.result, GetPromptResult)
-                for prompt_called in self.mcp_prompts_called
+                for prompt_called in mcp_prompts_called
             ):
                 raise TypeError(
                     "The 'prompts_called' must be a list of 'MCPPromptCall' with result of type 'GetPromptResult' from mcp.types"
                 )
+
+        return data

{deepeval-3.4.3 → deepeval-3.4.5}/deepeval/tracing/context.py

@@ -4,7 +4,6 @@ from contextvars import ContextVar
 from deepeval.tracing.types import BaseSpan, Trace
 from deepeval.test_case.llm_test_case import ToolCall, LLMTestCase
 from deepeval.tracing.types import LlmSpan, RetrieverSpan
-from deepeval.metrics import BaseMetric
 
 current_span_context: ContextVar[Optional[BaseSpan]] = ContextVar(
     "current_span", default=None

{deepeval-3.4.3 → deepeval-3.4.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "deepeval"
-version = "3.4.3"
+version = "3.4.5"
 description = "The LLM Evaluation Framework"
 authors = ["Jeffrey Ip <jeffreyip@confident-ai.com>"]
 license = "Apache-2.0"

deepeval-3.4.3/deepeval/_version.py

@@ -1 +0,0 @@
-__version__: str = "3.4.3"