azure-ai-evaluation 0.0.0b0__py3-none-any.whl → 1.0.0b1__py3-none-any.whl

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

@@ -0,0 +1,140 @@
+# ---------------------------------------------------------
+# 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 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
+
+logger = logging.getLogger(__name__)
+
+
+class IndirectAttackEvaluator:
+    """A Cross-Domain Prompt Injection Attack (XPIA) jailbreak evaluator.
+
+    Detect whether cross domain injected attacks are present in your AI system's response.
+
+    :param azure_ai_project: The scope of the Azure AI project. It contains subscription id, resource group, and project
+        name.
+    :type azure_ai_project: ~azure.ai.evaluation.AzureAIProject
+    :param eval_last_turn: Set to True to evaluate only the most recent exchange in the dialogue,
+        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
+    :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.
+    :rtype: Callable
+        **Usage**
+
+        .. code-block:: python
+
+            eval_fn = IndirectAttackEvaluator(model_config)
+            result = eval_fn(query="What is the capital of France?", response="Paris.")
+
+        **Output format for question-answer pair**
+
+        .. code-block:: python
+
+            {
+                'xpia_label': False,
+                'xpia_reason': 'The conversation does not contain any manipulated content, intrusion or
+                              information gathering.'
+                'xpia_information_gathering': False,
+                'xpia_intrusion': False
+                'xpia_manipulated_content': False
+            }
+    """
+
+    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__(
+        self,
+        *,
+        query: Optional[str],
+        response: Optional[str],
+        **kwargs,
+    ):
+        """
+        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,
+        )
+        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

@@ -0,0 +1,107 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+"""This includes enums and classes for exceptions for use in azure-ai-evaluation."""
+
+from enum import Enum
+
+from azure.core.exceptions import AzureError
+
+
+class ErrorCategory(Enum):
+    """Error category to be specified when using EvaluationException class.
+
+    When using EvaluationException, specify the type that best describes the nature of the error being captured.
+
+    * INVALID_VALUE -> One or more inputs are invalid (e.g. incorrect type or format)
+    * UNKNOWN_FIELD -> A least one unrecognized parameter is specified
+    * MISSING_FIELD -> At least one required parameter is missing
+    * FILE_OR_FOLDER_NOT_FOUND -> One or more files or folder paths do not exist
+    * RESOURCE_NOT_FOUND -> Resource could not be found
+    * FAILED_EXECUTION -> Execution failed
+    * SERVICE_UNAVAILABLE -> Service is unavailable
+    * UNKNOWN -> Undefined placeholder. Avoid using.
+    """
+
+    INVALID_VALUE = "INVALID VALUE"
+    UNKNOWN_FIELD = "UNKNOWN FIELD"
+    MISSING_FIELD = "MISSING FIELD"
+    FILE_OR_FOLDER_NOT_FOUND = "FILE OR FOLDER NOT FOUND"
+    RESOURCE_NOT_FOUND = "RESOURCE NOT FOUND"
+    FAILED_EXECUTION = "FAILED_EXECUTION"
+    SERVICE_UNAVAILABLE = "SERVICE UNAVAILABLE"
+    UNKNOWN = "UNKNOWN"
+
+
+class ErrorBlame(Enum):
+    """Source of blame to be specified when using EvaluationException class.
+
+    When using EvaluationException, specify whether the error is due to user actions or the system.
+    """
+
+    USER_ERROR = "UserError"
+    SYSTEM_ERROR = "SystemError"
+    UNKNOWN = "Unknown"
+
+
+class ErrorTarget(Enum):
+    """Error target to be specified when using EvaluationException class.
+
+    When using EvaluationException, specify the code area that was being targeted when the
+    exception was triggered.
+    """
+
+    EVAL_RUN = "EvalRun"
+    CODE_CLIENT = "CodeClient"
+    RAI_CLIENT = "RAIClient"
+    CHAT_EVALUATOR = "ChatEvaluator"
+    COHERENCE_EVALUATOR = "CoherenceEvaluator"
+    CONTENT_SAFETY_CHAT_EVALUATOR = "ContentSafetyEvaluator"
+    ECI_EVALUATOR = "ECIEvaluator"
+    F1_EVALUATOR = "F1Evaluator"
+    GROUNDEDNESS_EVALUATOR = "GroundednessEvaluator"
+    PROTECTED_MATERIAL_EVALUATOR = "ProtectedMaterialEvaluator"
+    RELEVANCE_EVALUATOR = "RelevanceEvaluator"
+    SIMILARITY_EVALUATOR = "SimilarityEvaluator"
+    INDIRECT_ATTACK_EVALUATOR = "IndirectAttackEvaluator"
+    INDIRECT_ATTACK_SIMULATOR = "IndirectAttackSimulator"
+    ADVERSARIAL_SIMULATOR = "AdversarialSimulator"
+    DIRECT_ATTACK_SIMULATOR = "DirectAttackSimulator"
+    EVALUATE = "Evaluate"
+    CALLBACK_CONVERSATION_BOT = "CallbackConversationBot"
+    MODELS = "Models"
+    UNKNOWN = "Unknown"
+    CONVERSATION = "Conversation"
+
+
+class EvaluationException(AzureError):
+    """The base class for all exceptions raised in pazure-ai-evaluation. If there is a need to define a custom
+    exception type, that custom exception type should extend from this class.
+
+    :param message: A message describing the error. This is the error message the user will see.
+    :type message: str
+    :param internal_message: The error message without any personal data. This will be pushed to telemetry logs.
+    :type internal_message: str
+    :param target: The name of the element that caused the exception to be thrown.
+    :type target: ~azure.ai.evaluation._exceptions.ErrorTarget
+    :param error_category: The error category, defaults to Unknown.
+    :type error_category: ~azure.ai.evaluation._exceptionsErrorCategory
+    :param error: The original exception if any.
+    :type error: Exception
+    """
+
+    def __init__(
+        self,
+        message: str,
+        internal_message: str,
+        *args,
+        target: ErrorTarget = ErrorTarget.UNKNOWN,
+        category: ErrorCategory = ErrorCategory.UNKNOWN,
+        blame: ErrorBlame = ErrorBlame.UNKNOWN,
+        **kwargs,
+    ) -> None:
+        self.category = category
+        self.target = target
+        self.blame = blame
+        self.internal_message = internal_message
+        super().__init__(message, *args, **kwargs)

azure/ai/evaluation/_http_utils.py

@@ -0,0 +1,395 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+
+from functools import wraps
+from typing import Any, Awaitable, Callable, Dict, MutableMapping, Optional
+
+from azure.core.configuration import Configuration
+from azure.core.pipeline import AsyncPipeline, Pipeline
+from azure.core.pipeline.policies import (
+    AsyncRedirectPolicy,
+    AsyncRetryPolicy,
+    CustomHookPolicy,
+    HeadersPolicy,
+    HttpLoggingPolicy,
+    NetworkTraceLoggingPolicy,
+    ProxyPolicy,
+    RedirectPolicy,
+    RetryPolicy,
+    UserAgentPolicy,
+)
+from azure.core.pipeline.transport import (  # pylint: disable=non-abstract-transport-import,no-name-in-module
+    AsyncHttpTransport,
+    AsyncioRequestsTransport,
+    HttpTransport,
+    RequestsTransport,
+)
+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]):
+    """Decorator to generate convenience methods for HTTP method.
+
+    :param Callable[["HttpPipeline"],None] f: A HttpPipeline classmethod to wrap.
+        The f.__name__ is the HTTP method used
+    :return: A wrapped callable that sends a `f.__name__` request
+    :rtype: Callable
+    """
+
+    @wraps(f)
+    def request_fn(
+        self: "HttpPipeline",
+        url: str,
+        *,
+        params: Optional[ParamsType] = None,
+        headers: Optional[MutableMapping[str, str]] = None,
+        json: Any = None,
+        content: Optional[ContentType] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[FilesType] = None,
+        **kwargs,
+    ) -> HttpResponse:
+        return self.request(
+            f.__name__.upper(),
+            url,
+            params=params,
+            headers=headers,
+            json=json,
+            content=content,
+            data=data,
+            files=files,
+            **kwargs,
+        )
+
+    return request_fn
+
+
+def _async_request_fn(f: Callable[["AsyncHttpPipeline"], Awaitable[None]]):
+    """Decorator to generate convenience methods for HTTP method.
+
+    :param Callable[["HttpPipeline"],None] f: A HttpPipeline classmethod to wrap.
+        The f.__name__ is the HTTP method used
+    :return: A wrapped callable that sends a `f.__name__` request
+    :rtype: Callable
+    """
+
+    @wraps(f)
+    async def request_fn(
+        self: "AsyncHttpPipeline",
+        url: str,
+        *,
+        params: Optional[ParamsType] = None,
+        headers: Optional[MutableMapping[str, str]] = None,
+        json: Any = None,
+        content: Optional[ContentType] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[FilesType] = None,
+        **kwargs,
+    ) -> AsyncHttpResponse:
+        return await self.request(
+            f.__name__.upper(),
+            url,
+            params=params,
+            headers=headers,
+            json=json,
+            content=content,
+            data=data,
+            files=files,
+            **kwargs,
+        )
+
+    return request_fn
+
+
+class HttpPipeline(Pipeline):
+    """A *very* thin wrapper over azure.core.pipeline.Pipeline that facilitates sending miscellaneous http requests by
+    adding:
+
+    * A requests-style api for sending http requests
+    * Facilities for populating policies for the client, include defaults,
+     and re-using policies from an existing client.
+    """
+
+    def __init__(
+        self,
+        *,
+        transport: Optional[HttpTransport] = None,
+        config: Optional[Configuration] = None,
+        user_agent_policy: Optional[UserAgentPolicy] = None,
+        headers_policy: Optional[HeadersPolicy] = None,
+        proxy_policy: Optional[ProxyPolicy] = None,
+        logging_policy: Optional[NetworkTraceLoggingPolicy] = None,
+        http_logging_policy: Optional[HttpLoggingPolicy] = None,
+        retry_policy: Optional[RetryPolicy] = None,
+        custom_hook_policy: Optional[CustomHookPolicy] = None,
+        redirect_policy: Optional[RedirectPolicy] = None,
+        **kwargs,
+    ):
+        """
+
+        :param HttpTransport transport: Http Transport used for requests, defaults to RequestsTransport
+        :param Configuration config:
+        :param UserAgentPolicy user_agent_policy:
+        :param HeadersPolicy headers_policy:
+        :param ProxyPolicy proxy_policy:
+        :param NetworkTraceLoggingPolicy logging_policy:
+        :param HttpLoggingPolicy http_logging_policy:
+        :param RetryPolicy retry_policy:
+        :param CustomHookPolicy custom_hook_policy:
+        :param RedirectPolicy redirect_policy:
+        """
+        config = config or Configuration()
+        config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs)
+        config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs)
+        config.redirect_policy = redirect_policy or config.redirect_policy or RedirectPolicy(**kwargs)
+        config.retry_policy = retry_policy or config.retry_policy or RetryPolicy(**kwargs)
+        config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs)
+        config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs)
+        config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs)
+        config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs)
+        config.polling_interval = kwargs.get("polling_interval", 30)
+
+        super().__init__(
+            # RequestsTransport normally should not be imported outside of azure.core, since transports
+            # are meant to be user configurable.
+            # RequestsTransport is only used in this file as the default transport when not user specified.
+            transport=transport or RequestsTransport(**kwargs),
+            policies=[
+                config.headers_policy,
+                config.user_agent_policy,
+                config.proxy_policy,
+                config.redirect_policy,
+                config.retry_policy,
+                config.authentication_policy,
+                config.custom_hook_policy,
+                config.logging_policy,
+            ],
+        )
+
+        self._config = config
+
+    def with_policies(self, **kwargs) -> Self:
+        """A named constructor which facilitates creating a new pipeline using an existing one as a base.
+
+           Accepts the same parameters as __init__
+
+        :return: new Pipeline object with combined config of current object
+            and specified overrides
+        :rtype: Self
+        """
+        cls = self.__class__
+        return cls(config=self._config, transport=kwargs.pop("transport", self._transport), **kwargs)
+
+    def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: Optional[ParamsType] = None,
+        headers: Optional[MutableMapping[str, str]] = None,
+        json: Any = None,
+        content: Optional[ContentType] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[FilesType] = None,
+        **kwargs,
+    ) -> HttpResponse:
+
+        request = HttpRequest(
+            method,
+            url,
+            params=params,
+            headers=headers,
+            json=json,
+            content=content,
+            data=data,
+            files=files,
+        )
+
+        return self.run(request, **kwargs).http_response
+
+    @_request_fn
+    def delete(self) -> None:
+        """Send a DELETE request."""
+
+    @_request_fn
+    def put(self) -> None:
+        """Send a PUT request."""
+
+    @_request_fn
+    def get(self) -> None:
+        """Send a GET request."""
+
+    @_request_fn
+    def post(self) -> None:
+        """Send a POST request."""
+
+    @_request_fn
+    def head(self) -> None:
+        """Send a HEAD request."""
+
+    @_request_fn
+    def options(self) -> None:
+        """Send a OPTIONS request."""
+
+    @_request_fn
+    def patch(self) -> None:
+        """Send a PATCH request."""
+
+
+class AsyncHttpPipeline(AsyncPipeline):
+    """A *very* thin wrapper over azure.core.pipeline.AsyncPipeline that facilitates sending miscellaneous
+    http requests by adding:
+
+    * A requests-style api for sending http requests
+    * Facilities for populating policies for the client, include defaults,
+     and re-using policies from an existing client.
+    """
+
+    def __init__(
+        self,
+        *,
+        transport: Optional[AsyncHttpTransport] = None,
+        config: Optional[Configuration] = None,
+        user_agent_policy: Optional[UserAgentPolicy] = None,
+        headers_policy: Optional[HeadersPolicy] = None,
+        proxy_policy: Optional[ProxyPolicy] = None,
+        logging_policy: Optional[NetworkTraceLoggingPolicy] = None,
+        http_logging_policy: Optional[HttpLoggingPolicy] = None,
+        retry_policy: Optional[AsyncRetryPolicy] = None,
+        custom_hook_policy: Optional[CustomHookPolicy] = None,
+        redirect_policy: Optional[AsyncRedirectPolicy] = None,
+        **kwargs,
+    ):
+        """
+
+        :param HttpTransport transport: Http Transport used for requests, defaults to RequestsTransport
+        :param Configuration config:
+        :param UserAgentPolicy user_agent_policy:
+        :param HeadersPolicy headers_policy:
+        :param ProxyPolicy proxy_policy:
+        :param NetworkTraceLoggingPolicy logging_policy:
+        :param HttpLoggingPolicy http_logging_policy:
+        :param AsyncRetryPolicy retry_policy:
+        :param CustomHookPolicy custom_hook_policy:
+        :param AsyncRedirectPolicy redirect_policy:
+        """
+        config = config or Configuration()
+        config.headers_policy = headers_policy or config.headers_policy or HeadersPolicy(**kwargs)
+        config.proxy_policy = proxy_policy or config.proxy_policy or ProxyPolicy(**kwargs)
+        config.redirect_policy = redirect_policy or config.redirect_policy or AsyncRedirectPolicy(**kwargs)
+        config.retry_policy = retry_policy or config.retry_policy or AsyncRetryPolicy(**kwargs)
+        config.custom_hook_policy = custom_hook_policy or config.custom_hook_policy or CustomHookPolicy(**kwargs)
+        config.logging_policy = logging_policy or config.logging_policy or NetworkTraceLoggingPolicy(**kwargs)
+        config.http_logging_policy = http_logging_policy or config.http_logging_policy or HttpLoggingPolicy(**kwargs)
+        config.user_agent_policy = user_agent_policy or config.user_agent_policy or UserAgentPolicy(**kwargs)
+        config.polling_interval = kwargs.get("polling_interval", 30)
+
+        super().__init__(
+            # AsyncioRequestsTransport normally should not be imported outside of azure.core, since transports
+            # are meant to be user configurable.
+            # AsyncioRequestsTransport is only used in this file as the default transport when not user specified.
+            transport=transport or AsyncioRequestsTransport(**kwargs),
+            policies=[
+                config.headers_policy,
+                config.user_agent_policy,
+                config.proxy_policy,
+                config.redirect_policy,
+                config.retry_policy,
+                config.authentication_policy,
+                config.custom_hook_policy,
+                config.logging_policy,
+            ],
+        )
+
+        self._config = config
+
+    def with_policies(self, **kwargs) -> Self:
+        """A named constructor which facilitates creating a new pipeline using an existing one as a base.
+
+           Accepts the same parameters as __init__
+
+        :return: new Pipeline object with combined config of current object
+            and specified overrides
+        :rtype: Self
+        """
+        cls = self.__class__
+        return cls(config=self._config, transport=kwargs.pop("transport", self._transport), **kwargs)
+
+    async def request(
+        self,
+        method: str,
+        url: str,
+        *,
+        params: Optional[ParamsType] = None,
+        headers: Optional[MutableMapping[str, str]] = None,
+        json: Any = None,
+        content: Optional[ContentType] = None,
+        data: Optional[Dict[str, Any]] = None,
+        files: Optional[FilesType] = None,
+        **kwargs,
+    ) -> AsyncHttpResponse:
+
+        request = HttpRequest(
+            method,
+            url,
+            params=params,
+            headers=headers,
+            json=json,
+            content=content,
+            data=data,
+            files=files,
+        )
+
+        return (await self.run(request, **kwargs)).http_response
+
+    @_async_request_fn
+    async def delete(self) -> None:
+        """Send a DELETE request."""
+
+    @_async_request_fn
+    async def put(self) -> None:
+        """Send a PUT request."""
+
+    @_async_request_fn
+    async def get(self) -> None:
+        """Send a GET request."""
+
+    @_async_request_fn
+    async def post(self) -> None:
+        """Send a POST request."""
+
+    @_async_request_fn
+    async def head(self) -> None:
+        """Send a HEAD request."""
+
+    @_async_request_fn
+    async def options(self) -> None:
+        """Send a OPTIONS request."""
+
+    @_async_request_fn
+    async def patch(self) -> None:
+        """Send a PATCH request."""
+
+
+def get_http_client() -> HttpPipeline:
+    """Get an HttpPipeline configured with common policies.
+
+    :returns: An HttpPipeline with a set of applied policies:
+    :rtype: HttpPipeline
+    """
+    return HttpPipeline(user_agent_policy=UserAgentPolicy(base_user_agent=USER_AGENT))
+
+
+def get_async_http_client() -> AsyncHttpPipeline:
+    """Get an AsyncHttpPipeline configured with common policies.
+
+    :returns: An AsyncHttpPipeline with a set of applied policies:
+    :rtype: AsyncHttpPipeline
+    """
+    return AsyncHttpPipeline(user_agent_policy=UserAgentPolicy(base_user_agent=USER_AGENT))

azure/ai/evaluation/_model_configurations.py

@@ -0,0 +1,27 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+from typing import TypedDict
+
+
+class AzureOpenAIModelConfigurationBase(TypedDict):
+    azure_deployment: str
+    azure_endpoint: str
+    api_key: str
+
+
+class AzureOpenAIModelConfiguration(AzureOpenAIModelConfigurationBase, total=False):
+    api_version: str
+
+
+class OpenAIModelConfiguration(TypedDict):
+    api_key: str
+    base_url: str
+    organization: str
+
+
+class AzureAIProject(TypedDict):
+    subscription_id: str
+    resource_group_name: str
+    project_name: str

azure/ai/evaluation/_user_agent.py

@@ -0,0 +1,6 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from azure.ai.evaluation._version import VERSION
+
+USER_AGENT = "{}/{}".format("azure-ai-evaluation", VERSION)

azure/ai/evaluation/_version.py

@@ -0,0 +1,5 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+
+VERSION = "1.0.0b1"