azure-ai-evaluation 1.0.0b1__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

azure/ai/evaluation/_evaluators/_similarity/similarity.prompty

@@ -3,11 +3,6 @@ name: Similarity
 description: Evaluates similarity score for QA scenario
 model:
   api: chat
-  configuration:
-    type: azure_openai
-    azure_deployment: ${env:AZURE_DEPLOYMENT}
-    api_key: ${env:AZURE_OPENAI_API_KEY}
-    azure_endpoint: ${env:AZURE_OPENAI_ENDPOINT}
   parameters:
     temperature: 0.0
     max_tokens: 1

azure/ai/evaluation/_evaluators/_xpia/xpia.py

@@ -2,19 +2,17 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 import logging
-from typing import Optional
-
-from promptflow._utils.async_utils import async_run_allowing_running_loop
 
+from typing import Optional
+from typing_extensions import override
 from azure.ai.evaluation._common.constants import EvaluationMetrics
-from azure.ai.evaluation._common.rai_service import evaluate_with_rai_service
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
-from azure.ai.evaluation._model_configurations import AzureAIProject
+from azure.ai.evaluation._evaluators._common import RaiServiceEvaluatorBase
+
 
 logger = logging.getLogger(__name__)
 
 
-class IndirectAttackEvaluator:
+class IndirectAttackEvaluator(RaiServiceEvaluatorBase):
     """A Cross-Domain Prompt Injection Attack (XPIA) jailbreak evaluator.
 
     Detect whether cross domain injected attacks are present in your AI system's response.
@@ -26,7 +24,7 @@ class IndirectAttackEvaluator:
         focusing on the latest user inquiry and the assistant's corresponding response. Defaults to False
     :type eval_last_turn: bool
     :param credential: The credential for connecting to Azure AI project.
-    :type credential: ~azure.core.credentials.TokenCredential
+    :type credential: Optional[~azure.core.credentials.TokenCredential]
     :return: A function that evaluates and generates metrics for XPIA chat scenario. Metrics include the overall
         evaluation label and reason for the Q/A Pair, as well as sub-labels for manipulated content, intrusion, and
         information.
@@ -52,89 +50,16 @@ class IndirectAttackEvaluator:
             }
     """
 
-    def __init__(self, azure_ai_project: dict, eval_last_turn: bool = False, credential=None):
-        self._evaluator = _IndirectAttackEvaluator(azure_ai_project, credential)
-        self._eval_last_turn = eval_last_turn
-
-    def __call__(
+    @override
+    def __init__(
         self,
-        *,
-        query: Optional[str],
-        response: Optional[str],
-        **kwargs,
+        azure_ai_project: dict,
+        credential: Optional[dict] = None,
+        eval_last_turn: bool = False,
     ):
-        """
-        Evaluates content according to the presence of attacks injected into the conversation context to
-        interrupt normal expected functionality by eliciting manipulated content, intrusion and attempting
-        to gather information outside the scope of your AI system.
-        :keyword query: The query to be evaluated. Mutually exclusive with 'conversation'.
-        :paramtype query: Optional[str]
-        :keyword response: The response to be evaluated. Mutually exclusive with 'conversation'.
-        :paramtype response: Optional[str]
-        :return: The evaluation scores and reasoning.
-        :rtype: dict
-        """
-
-        return self._evaluator(query=query, response=response, **kwargs)
-
-
-class _AsyncIndirectAttackEvaluator:
-    def __init__(self, azure_ai_project: dict, credential=None):
-        self._azure_ai_project = azure_ai_project
-        self._credential = credential
-
-    async def __call__(self, *, query: str, response: str, **kwargs):
-        """
-        Evaluates content according to this evaluator's metric.
-        :keyword query: The query to be evaluated.
-        :paramtype query: str
-        :keyword response: The response to be evaluated.
-        :paramtype response: str
-        :return: The evaluation score computation based on the metric (self.metric).
-        :rtype: Any
-        """
-        # Validate inputs
-        # Raises value error if failed, so execution alone signifies success.
-        if not (query and query.strip() and query != "None") or not (
-            response and response.strip() and response != "None"
-        ):
-            msg = "Both 'query' and 'response' must be non-empty strings."
-            raise EvaluationException(
-                message=msg,
-                internal_message=msg,
-                error_category=ErrorCategory.MISSING_FIELD,
-                error_blame=ErrorBlame.USER_ERROR,
-                error_target=ErrorTarget.INDIRECT_ATTACK_EVALUATOR,
-            )
-
-        # Run score computation based on supplied metric.
-        result = await evaluate_with_rai_service(
-            metric_name=EvaluationMetrics.XPIA,
-            query=query,
-            response=response,
-            project_scope=self._azure_ai_project,
-            credential=self._credential,
+        super().__init__(
+            eval_metric=EvaluationMetrics.XPIA,
+            azure_ai_project=azure_ai_project,
+            credential=credential,
+            eval_last_turn=eval_last_turn,
         )
-        return result
-
-
-class _IndirectAttackEvaluator:
-    def __init__(self, azure_ai_project: dict, credential=None):
-        self._async_evaluator = _AsyncIndirectAttackEvaluator(azure_ai_project, credential)
-
-    def __call__(self, *, query: str, response: str, **kwargs):
-        """
-        Evaluates XPIA content.
-        :keyword query: The query to be evaluated.
-        :paramtype query: str
-        :keyword response: The response to be evaluated.
-        :paramtype response: str
-        :keyword context: The context to be evaluated.
-        :paramtype context: str
-        :return: The XPIA score.
-        :rtype: dict
-        """
-        return async_run_allowing_running_loop(self._async_evaluator, query=query, response=response, **kwargs)
-
-    def _to_async(self):
-        return self._async_evaluator

azure/ai/evaluation/_exceptions.py

@@ -54,7 +54,6 @@ class ErrorTarget(Enum):
     EVAL_RUN = "EvalRun"
     CODE_CLIENT = "CodeClient"
     RAI_CLIENT = "RAIClient"
-    CHAT_EVALUATOR = "ChatEvaluator"
     COHERENCE_EVALUATOR = "CoherenceEvaluator"
     CONTENT_SAFETY_CHAT_EVALUATOR = "ContentSafetyEvaluator"
     ECI_EVALUATOR = "ECIEvaluator"

azure/ai/evaluation/_http_utils.py

@@ -6,6 +6,9 @@
 from functools import wraps
 from typing import Any, Awaitable, Callable, Dict, MutableMapping, Optional
 
+from typing_extensions import Self
+
+from azure.ai.evaluation._user_agent import USER_AGENT
 from azure.core.configuration import Configuration
 from azure.core.pipeline import AsyncPipeline, Pipeline
 from azure.core.pipeline.policies import (
@@ -28,9 +31,6 @@ from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-tran
 )
 from azure.core.rest import AsyncHttpResponse, HttpRequest, HttpResponse
 from azure.core.rest._rest_py3 import ContentType, FilesType, ParamsType
-from typing_extensions import Self
-
-from azure.ai.evaluation._user_agent import USER_AGENT
 
 
 def _request_fn(f: Callable[["HttpPipeline"], None]):

azure/ai/evaluation/_model_configurations.py

@@ -2,26 +2,54 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 
-from typing import TypedDict
+from typing import Dict, Literal, TypedDict
 
+from typing_extensions import NotRequired
 
-class AzureOpenAIModelConfigurationBase(TypedDict):
+
+class AzureOpenAIModelConfiguration(TypedDict, total=False):
+    """Model Configuration for Azure OpenAI Model"""
+
+    type: Literal["azure_openai"]
+    """The type of the model configuration. Should be 'azure_openai' for AzureOpenAIModelConfiguration"""
     azure_deployment: str
+    """Name of Azure OpenAI deployment to make request to"""
     azure_endpoint: str
+    """Endpoint of Azure OpenAI resource to make request to"""
     api_key: str
+    """API key of Azure OpenAI resource"""
+    api_version: NotRequired[str]
+    """(Optional) API version to use in request to Azure OpenAI deployment"""
 
 
-class AzureOpenAIModelConfiguration(AzureOpenAIModelConfigurationBase, total=False):
-    api_version: str
+class OpenAIModelConfiguration(TypedDict, total=False):
+    """Model Configuration for OpenAI Model"""
 
-
-class OpenAIModelConfiguration(TypedDict):
+    type: Literal["openai"]
+    """The type of the model configuration. Should be 'openai' for OpenAIModelConfiguration"""
     api_key: str
-    base_url: str
-    organization: str
+    "API key needed to make request to model"
+    model: str
+    """Name of model to be used in OpenAI request"""
+    base_url: NotRequired[str]
+    """(Optional) Base URL to be used in OpenAI request"""
+    organization: NotRequired[str]
+    """(Optional) OpenAI organization"""
 
 
 class AzureAIProject(TypedDict):
+    """Azure AI Project Information"""
+
     subscription_id: str
+    """Azure subscription id of the project"""
     resource_group_name: str
+    """Azure resource group name of the project"""
     project_name: str
+    """Azure project name"""
+
+
+class EvaluatorConfig(TypedDict, total=False):
+    """Configuration for an evaluator"""
+
+    column_mapping: Dict[str, str]
+    """Dictionary mapping evaluator input name to column in data"""

azure/ai/evaluation/_version.py

@@ -2,4 +2,4 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # ---------------------------------------------------------
 
-VERSION = "1.0.0b1"
+VERSION = "1.0.0b3"

azure/ai/evaluation/simulator/__init__.py

@@ -3,7 +3,7 @@ from ._adversarial_simulator import AdversarialSimulator
 from ._constants import SupportedLanguages
 from ._direct_attack_simulator import DirectAttackSimulator
 from ._indirect_attack_simulator import IndirectAttackSimulator
-from .simulator import Simulator
+from ._simulator import Simulator
 
 __all__ = [
     "AdversarialSimulator",

azure/ai/evaluation/simulator/_adversarial_simulator.py

@@ -8,16 +8,17 @@ import logging
 import random
 from typing import Any, Callable, Dict, List, Optional
 
-from azure.core.pipeline.policies import AsyncRetryPolicy, RetryMode
-from azure.identity import DefaultAzureCredential
 from tqdm import tqdm
 
+from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 from azure.ai.evaluation._http_utils import get_async_http_client
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 from azure.ai.evaluation._model_configurations import AzureAIProject
 from azure.ai.evaluation.simulator import AdversarialScenario
 from azure.ai.evaluation.simulator._adversarial_scenario import _UnstableAdversarialScenario
+from azure.core.pipeline.policies import AsyncRetryPolicy, RetryMode
+from azure.identity import DefaultAzureCredential
 
+from ._constants import SupportedLanguages
 from ._conversation import CallbackConversationBot, ConversationBot, ConversationRole
 from ._conversation._conversation import simulate_conversation
 from ._model_tools import (
@@ -27,9 +28,7 @@ from ._model_tools import (
     RAIClient,
     TokenScope,
 )
-from ._tracing import monitor_adversarial_scenario
 from ._utils import JsonLineList
-from ._constants import SupportedLanguages
 
 logger = logging.getLogger(__name__)
 
@@ -352,7 +351,10 @@ class AdversarialSimulator:
             )
 
         if role == ConversationRole.ASSISTANT:
-            dummy_model = lambda: None  # noqa: E731
+
+            def dummy_model() -> None:
+                return None
+
             dummy_model.name = "dummy_model"
             return CallbackConversationBot(
                 callback=target,

azure/ai/evaluation/simulator/_conversation/__init__.py

@@ -11,8 +11,8 @@ from typing import Any, Callable, Dict, List, Optional, Tuple, Union
 
 import jinja2
 
+from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 from azure.ai.evaluation._http_utils import AsyncHttpPipeline
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 
 from .._model_tools import LLMBase, OpenAIChatCompletionsModel
 from .constants import ConversationRole

azure/ai/evaluation/simulator/_conversation/_conversation.py

@@ -6,12 +6,12 @@ import asyncio
 import logging
 from typing import Callable, Dict, List, Tuple, Union
 
-from azure.ai.evaluation.simulator._helpers._language_suffix_mapping import SUPPORTED_LANGUAGES_MAPPING
+from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 from azure.ai.evaluation.simulator._constants import SupportedLanguages
+from azure.ai.evaluation.simulator._helpers._language_suffix_mapping import SUPPORTED_LANGUAGES_MAPPING
 
 from ..._http_utils import AsyncHttpPipeline
 from . import ConversationBot, ConversationTurn
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 
 
 def is_closing_message(response: Union[Dict, str], recursion_depth: int = 0) -> bool:
@@ -84,20 +84,20 @@ async def simulate_conversation(
     """
     Simulate a conversation between the given bots.
 
-    :param bots: List of ConversationBot instances participating in the conversation.
-    :type bots: List[ConversationBot]
-    :param session: The session to use for making API calls.
-    :type session: AsyncHttpPipeline
-    :param stopping_criteria: A callable that determines when the conversation should stop.
-    :type stopping_criteria: Callable[[str], bool]
-    :param turn_limit: The maximum number of turns in the conversation. Defaults to 10.
-    :type turn_limit: int
-    :param history_limit: The maximum number of turns to keep in the conversation history. Defaults to 5.
-    :type history_limit: int
-    :param api_call_delay_sec: Delay between API calls in seconds. Defaults to 0.
-    :type api_call_delay_sec: float
-    :param logger: The logger to use for logging. Defaults to the logger named after the current module.
-    :type logger: logging.Logger
+    :keyword bots: List of ConversationBot instances participating in the conversation.
+    :paramtype bots: List[ConversationBot]
+    :keyword session: The session to use for making API calls.
+    :paramtype session: AsyncHttpPipeline
+    :keyword stopping_criteria: A callable that determines when the conversation should stop.
+    :paramtype stopping_criteria: Callable[[str], bool]
+    :keyword turn_limit: The maximum number of turns in the conversation. Defaults to 10.
+    :paramtype turn_limit: int
+    :keyword history_limit: The maximum number of turns to keep in the conversation history. Defaults to 5.
+    :paramtype history_limit: int
+    :keyword api_call_delay_sec: Delay between API calls in seconds. Defaults to 0.
+    :paramtype api_call_delay_sec: float
+    :keyword logger: The logger to use for logging. Defaults to the logger named after the current module.
+    :paramtype logger: logging.Logger
     :return: Simulation a conversation between the given bots.
     :rtype: Tuple
     """

azure/ai/evaluation/simulator/_direct_attack_simulator.py

@@ -5,17 +5,17 @@
 import functools
 import logging
 from random import randint
-from typing import Any, Callable, Dict, Optional
-
-from azure.identity import DefaultAzureCredential
+from typing import Callable, Optional
 
 from promptflow._sdk._telemetry import ActivityType, monitor_operation
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
-from azure.ai.evaluation.simulator import AdversarialScenario
+
+from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 from azure.ai.evaluation._model_configurations import AzureAIProject
+from azure.ai.evaluation.simulator import AdversarialScenario
+from azure.identity import DefaultAzureCredential
 
-from ._model_tools import AdversarialTemplateHandler, ManagedIdentityAPITokenManager, RAIClient, TokenScope
 from ._adversarial_simulator import AdversarialSimulator
+from ._model_tools import AdversarialTemplateHandler, ManagedIdentityAPITokenManager, RAIClient, TokenScope
 
 logger = logging.getLogger(__name__)
 

azure/ai/evaluation/simulator/_helpers/__init__.py

@@ -1,4 +1,5 @@
-from ._simulator_data_classes import ConversationHistory, Turn
+from ._experimental import experimental
 from ._language_suffix_mapping import SUPPORTED_LANGUAGES_MAPPING
+from ._simulator_data_classes import ConversationHistory, Turn
 
-__all__ = ["ConversationHistory", "Turn", "SUPPORTED_LANGUAGES_MAPPING"]
+__all__ = ["ConversationHistory", "Turn", "SUPPORTED_LANGUAGES_MAPPING", "experimental"]

azure/ai/evaluation/simulator/_helpers/_experimental.py

@@ -0,0 +1,157 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+import functools
+import inspect
+import logging
+import sys
+from typing import Callable, Type, TypeVar, Union
+
+from typing_extensions import ParamSpec
+
+DOCSTRING_TEMPLATE = ".. note::    {0} {1}\n\n"
+DOCSTRING_DEFAULT_INDENTATION = 8
+EXPERIMENTAL_CLASS_MESSAGE = "This is an experimental class,"
+EXPERIMENTAL_METHOD_MESSAGE = "This is an experimental method,"
+EXPERIMENTAL_FIELD_MESSAGE = "This is an experimental field,"
+EXPERIMENTAL_LINK_MESSAGE = (
+    "and may change at any time. Please see https://aka.ms/azuremlexperimental for more information."
+)
+
+_warning_cache = set()
+module_logger = logging.getLogger(__name__)
+
+TExperimental = TypeVar("TExperimental", bound=Union[Type, Callable])
+P = ParamSpec("P")
+T = TypeVar("T")
+
+
+def experimental(wrapped: TExperimental) -> TExperimental:
+    """Add experimental tag to a class or a method.
+
+    :param wrapped: Either a Class or Function to mark as experimental
+    :type wrapped: TExperimental
+    :return: The wrapped class or method
+    :rtype: TExperimental
+    """
+    if inspect.isclass(wrapped):
+        return _add_class_docstring(wrapped)
+    if inspect.isfunction(wrapped):
+        return _add_method_docstring(wrapped)
+    return wrapped
+
+
+def _add_class_docstring(cls: Type[T]) -> Type[T]:
+    """Add experimental tag to the class doc string.
+
+    :return: The updated class
+    :rtype: Type[T]
+    """
+
+    P2 = ParamSpec("P2")
+
+    def _add_class_warning(func: Callable[P2, None]) -> Callable[P2, None]:
+        """Add warning message for class __init__.
+
+        :param func: The original __init__ function
+        :type func: Callable[P2, None]
+        :return: Updated __init__
+        :rtype: Callable[P2, None]
+        """
+
+        @functools.wraps(func)
+        def wrapped(*args, **kwargs):
+            message = "Class {0}: {1} {2}".format(cls.__name__, EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+            if not _should_skip_warning() and not _is_warning_cached(message):
+                module_logger.warning(message)
+            return func(*args, **kwargs)
+
+        return wrapped
+
+    doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_CLASS_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+    if cls.__doc__:
+        cls.__doc__ = _add_note_to_docstring(cls.__doc__, doc_string)
+    else:
+        cls.__doc__ = doc_string + ">"
+    cls.__init__ = _add_class_warning(cls.__init__)
+    return cls
+
+
+def _add_method_docstring(func: Callable[P, T] = None) -> Callable[P, T]:
+    """Add experimental tag to the method doc string.
+
+    :param func: The function to update
+    :type func: Callable[P, T]
+    :return: A wrapped method marked as experimental
+    :rtype: Callable[P,T]
+    """
+    doc_string = DOCSTRING_TEMPLATE.format(EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+    if func.__doc__:
+        func.__doc__ = _add_note_to_docstring(func.__doc__, doc_string)
+    else:
+        # '>' is required. Otherwise the note section can't be generated
+        func.__doc__ = doc_string + ">"
+
+    @functools.wraps(func)
+    def wrapped(*args: P.args, **kwargs: P.kwargs) -> T:
+        message = "Method {0}: {1} {2}".format(func.__name__, EXPERIMENTAL_METHOD_MESSAGE, EXPERIMENTAL_LINK_MESSAGE)
+        if not _should_skip_warning() and not _is_warning_cached(message):
+            module_logger.warning(message)
+        return func(*args, **kwargs)
+
+    return wrapped
+
+
+def _add_note_to_docstring(doc_string: str, note: str) -> str:
+    """Adds experimental note to docstring at the top and correctly indents original docstring.
+
+    :param doc_string: The docstring
+    :type doc_string: str
+    :param note: The note to add to the docstring
+    :type note: str
+    :return: Updated docstring
+    :rtype: str
+    """
+    indent = _get_indentation_size(doc_string)
+    doc_string = doc_string.rjust(len(doc_string) + indent)
+    return note + doc_string
+
+
+def _get_indentation_size(doc_string: str) -> int:
+    """Finds the minimum indentation of all non-blank lines after the first line.
+
+    :param doc_string: The docstring
+    :type doc_string: str
+    :return: Minimum number of indentation of the docstring
+    :rtype: int
+    """
+    lines = doc_string.expandtabs().splitlines()
+    indent = sys.maxsize
+    for line in lines[1:]:
+        stripped = line.lstrip()
+        if stripped:
+            indent = min(indent, len(line) - len(stripped))
+    return indent if indent < sys.maxsize else DOCSTRING_DEFAULT_INDENTATION
+
+
+def _should_skip_warning():
+    skip_warning_msg = False
+
+    # Cases where we want to suppress the warning:
+    # 1. When converting from REST object to SDK object
+    for frame in inspect.stack():
+        if frame.function == "_from_rest_object":
+            skip_warning_msg = True
+            break
+
+    return skip_warning_msg
+
+
+def _is_warning_cached(warning_msg):
+    # use cache to make sure we only print same warning message once under same session
+    # this prevents duplicated warnings got printed when user does a loop call on a method or a class
+    if warning_msg in _warning_cache:
+        return True
+    _warning_cache.add(warning_msg)
+    return False

azure/ai/evaluation/simulator/_helpers/_simulator_data_classes.py

@@ -3,7 +3,7 @@
 # ---------------------------------------------------------
 # pylint: disable=C0103,C0114,C0116
 from dataclasses import dataclass
-from typing import Union
+from typing import Dict, List, Optional, Union
 
 from azure.ai.evaluation.simulator._conversation.constants import ConversationRole
 
@@ -20,12 +20,12 @@ class Turn:
     content: str
     context: str = None
 
-    def to_dict(self):
+    def to_dict(self) -> Dict[str, Optional[str]]:
         """
         Convert the conversation turn to a dictionary.
 
-        Returns:
-            dict: A dictionary representation of the conversation turn.
+        :returns: A dictionary representation of the conversation turn.
+        :rtype: Dict[str, Optional[str]]
         """
         return {
             "role": self.role.value if isinstance(self.role, ConversationRole) else self.role,
@@ -34,12 +34,6 @@ class Turn:
         }
 
     def __repr__(self):
-        """
-        Return the string representation of the conversation turn.
-
-        Returns:
-            str: A string representation of the conversation turn.
-        """
         return f"Turn(role={self.role}, content={self.content})"
 
 
@@ -52,42 +46,30 @@ class ConversationHistory:
         """
         Initializes the conversation history with an empty list of turns.
         """
-        self.history = []
+        self.history: List[Turn] = []
 
     def add_to_history(self, turn: Turn):
         """
         Adds a turn to the conversation history.
 
-        Args:
-            turn (Turn): The conversation turn to add.
+        :param turn: The conversation turn to add.
+        :type turn: Turn
         """
         self.history.append(turn)
 
-    def to_list(self):
+    def to_list(self) -> List[Dict[str, str]]:
         """
         Converts the conversation history to a list of dictionaries.
 
-        Returns:
-            list: A list of dictionaries representing the conversation turns.
+        :returns: A list of dictionaries representing the conversation turns.
+        :rtype: List[Dict[str, str]]
         """
         return [turn.to_dict() for turn in self.history]
 
-    def get_length(self):
-        """
-        Returns the length of the conversation.
-
-        Returns:
-            int: The number of turns in the conversation history.
-        """
+    def __len__(self) -> int:
         return len(self.history)
 
     def __repr__(self):
-        """
-        Returns the string representation of the conversation history.
-
-        Returns:
-            str: A string representation of the conversation history.
-        """
         for turn in self.history:
             print(turn)
         return ""

azure/ai/evaluation/simulator/_indirect_attack_simulator.py

@@ -4,17 +4,17 @@
 # noqa: E501
 import functools
 import logging
-from typing import Any, Callable, Dict
-
-from azure.identity import DefaultAzureCredential
+from typing import Callable
 
 from promptflow._sdk._telemetry import ActivityType, monitor_operation
-from azure.ai.evaluation.simulator import AdversarialScenario
+
+from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
 from azure.ai.evaluation._model_configurations import AzureAIProject
+from azure.ai.evaluation.simulator import AdversarialScenario
+from azure.identity import DefaultAzureCredential
 
-from ._model_tools import AdversarialTemplateHandler, ManagedIdentityAPITokenManager, RAIClient, TokenScope
-from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 from ._adversarial_simulator import AdversarialSimulator
+from ._model_tools import AdversarialTemplateHandler, ManagedIdentityAPITokenManager, RAIClient, TokenScope
 
 logger = logging.getLogger(__name__)