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

azure/ai/evaluation/_evaluate/{_batch_run → _batch_run_client}/code_client.py

@@ -4,17 +4,13 @@
 import inspect
 import json
 import logging
-import os
-from concurrent.futures import Future
-from pathlib import Path
-from typing import Any, Callable, Dict, Optional, Union, cast
 
 import pandas as pd
-from promptflow.contracts.types import AttrDict
-from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
 
+from promptflow.contracts.types import AttrDict
 from azure.ai.evaluation._evaluate._utils import _apply_column_mapping, _has_aggregator, get_int_env_var, load_jsonl
-from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
+from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
+from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 
 from ..._constants import PF_BATCH_TIMEOUT_SEC, PF_BATCH_TIMEOUT_SEC_DEFAULT
 
@@ -22,43 +18,35 @@ LOGGER = logging.getLogger(__name__)
 
 
 class CodeRun:
-    def __init__(
-        self,
-        *,
-        run: Future,
-        input_data,
-        evaluator_name: Optional[str] = None,
-        aggregator: Callable[["CodeRun"], Future],
-        **kwargs,  # pylint: disable=unused-argument
-    ) -> None:
+    def __init__(self, run, input_data, evaluator_name=None, aggregated_metrics=None, **kwargs):
         self.run = run
         self.evaluator_name = evaluator_name if evaluator_name is not None else ""
         self.input_data = input_data
-        self.aggregated_metrics = aggregator(self)
+        self.aggregated_metrics = aggregated_metrics
 
-    def get_result_df(self, exclude_inputs: bool = False) -> pd.DataFrame:
+    def get_result_df(self, exclude_inputs=False):
         batch_run_timeout = get_int_env_var(PF_BATCH_TIMEOUT_SEC, PF_BATCH_TIMEOUT_SEC_DEFAULT)
-        result_df = cast(pd.DataFrame, self.run.result(timeout=batch_run_timeout))
+        result_df = self.run.result(timeout=batch_run_timeout)
         if exclude_inputs:
             result_df = result_df.drop(columns=[col for col in result_df.columns if col.startswith("inputs.")])
         return result_df
 
-    def get_aggregated_metrics(self) -> Dict[str, Any]:
+    def get_aggregated_metrics(self):
         try:
             batch_run_timeout = get_int_env_var(PF_BATCH_TIMEOUT_SEC, PF_BATCH_TIMEOUT_SEC_DEFAULT)
-            aggregated_metrics: Optional[Any] = (
-                cast(Dict, self.aggregated_metrics.result(timeout=batch_run_timeout))
+            aggregated_metrics = (
+                self.aggregated_metrics.result(timeout=batch_run_timeout)
                 if self.aggregated_metrics is not None
                 else None
             )
         except Exception as ex:  # pylint: disable=broad-exception-caught
-            LOGGER.debug("Error calculating metrics for evaluator %s, failed with error %s", self.evaluator_name, ex)
+            LOGGER.debug(f"Error calculating metrics for evaluator {self.evaluator_name}, failed with error {str(ex)}")
             aggregated_metrics = None
 
         if not isinstance(aggregated_metrics, dict):
             LOGGER.warning(
-                "Aggregated metrics for evaluator %s is not a dictionary will not be logged as metrics",
-                self.evaluator_name,
+                f"Aggregated metrics for evaluator {self.evaluator_name}"
+                f" is not a dictionary will not be logged as metrics"
             )
 
         aggregated_metrics = aggregated_metrics if isinstance(aggregated_metrics, dict) else {}
@@ -66,15 +54,11 @@ class CodeRun:
         return aggregated_metrics
 
 
-class CodeClient:  # pylint: disable=client-accepts-api-version-keyword
-    def __init__(  # pylint: disable=missing-client-constructor-parameter-credential,missing-client-constructor-parameter-kwargs
-        self,
-    ) -> None:
+class CodeClient:
+    def __init__(self):
         self._thread_pool = ThreadPoolExecutor(thread_name_prefix="evaluators_thread")
 
-    def _calculate_metric(
-        self, evaluator: Callable, input_df: pd.DataFrame, column_mapping: Optional[Dict[str, str]], evaluator_name: str
-    ) -> pd.DataFrame:
+    def _calculate_metric(self, evaluator, input_df, column_mapping, evaluator_name):
         row_metric_futures = []
         row_metric_results = []
         input_df = _apply_column_mapping(input_df, column_mapping)
@@ -111,10 +95,10 @@ class CodeClient:  # pylint: disable=client-accepts-api-version-keyword
             verify_integrity=True,
         )
 
-    @staticmethod
-    def _calculate_aggregations(evaluator: Callable, run: CodeRun) -> Any:
+    def _calculate_aggregations(self, evaluator, run):
         try:
             if _has_aggregator(evaluator):
+                aggregate_input = None
                 evaluator_output = run.get_result_df(exclude_inputs=True)
                 if len(evaluator_output.columns) == 1 and evaluator_output.columns[0] == "output":
                     aggregate_input = evaluator_output["output"].tolist()
@@ -126,25 +110,18 @@ class CodeClient:  # pylint: disable=client-accepts-api-version-keyword
                 return aggregated_output
         except Exception as ex:  # pylint: disable=broad-exception-caught
             LOGGER.warning(
-                "Error calculating aggregations for evaluator %s, failed with error %s", run.evaluator_name, ex
+                f"Error calculating aggregations for evaluator {run.evaluator_name}," f" failed with error {str(ex)}"
             )
         return None
 
-    def run(
-        self,  # pylint: disable=unused-argument
-        flow: Callable,
-        data: Union[os.PathLike, Path, pd.DataFrame],
-        evaluator_name: Optional[str] = None,
-        column_mapping: Optional[Dict[str, str]] = None,
-        **kwargs,
-    ) -> CodeRun:
+    def run(self, flow, data, evaluator_name=None, column_mapping=None, **kwargs):
         input_df = data
         if not isinstance(input_df, pd.DataFrame):
             try:
                 json_data = load_jsonl(data)
             except json.JSONDecodeError as exc:
                 raise EvaluationException(
-                    message=f"Failed to parse data as JSON: {data}. Provide valid json lines data.",
+                    message = f"Failed to parse data as JSON: {data}. Provide valid json lines data.",
                     internal_message="Failed to parse data as JSON",
                     target=ErrorTarget.CODE_CLIENT,
                     category=ErrorCategory.INVALID_VALUE,
@@ -152,37 +129,22 @@ class CodeClient:  # pylint: disable=client-accepts-api-version-keyword
                 ) from exc
 
             input_df = pd.DataFrame(json_data)
-        eval_future = self._thread_pool.submit(
-            self._calculate_metric,
-            evaluator=flow,
-            input_df=input_df,
-            column_mapping=column_mapping,
-            evaluator_name=evaluator_name,
-        )
+        eval_future = self._thread_pool.submit(self._calculate_metric, flow, input_df, column_mapping, evaluator_name)
+        run = CodeRun(run=eval_future, input_data=data, evaluator_name=evaluator_name, aggregated_metrics=None)
+        aggregation_future = self._thread_pool.submit(self._calculate_aggregations, evaluator=flow, run=run)
+        run.aggregated_metrics = aggregation_future
+        return run
 
-        return CodeRun(
-            run=eval_future,
-            input_data=data,
-            evaluator_name=evaluator_name,
-            aggregator=lambda code_run: self._thread_pool.submit(
-                self._calculate_aggregations, evaluator=flow, run=code_run
-            ),
-        )
-
-    def get_details(self, run: CodeRun, all_results: bool = False) -> pd.DataFrame:
+    def get_details(self, run, all_results=False):
         result_df = run.get_result_df(exclude_inputs=not all_results)
         return result_df
 
-    def get_metrics(self, run: CodeRun) -> Dict[str, Any]:
+    def get_metrics(self, run):
         try:
             aggregated_metrics = run.get_aggregated_metrics()
             print("Aggregated metrics")
             print(aggregated_metrics)
         except Exception as ex:  # pylint: disable=broad-exception-caught
-            LOGGER.debug("Error calculating metrics for evaluator %s, failed with error %s", run.evaluator_name, ex)
-            return {}
+            LOGGER.debug(f"Error calculating metrics for evaluator {run.evaluator_name}, failed with error {str(ex)}")
+            return None
         return aggregated_metrics
-
-    def get_run_summary(self, run: CodeRun) -> Any:  # pylint: disable=unused-argument
-        # Not implemented
-        return None

azure/ai/evaluation/_evaluate/_batch_run_client/proxy_client.py

@@ -0,0 +1,61 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import inspect
+import logging
+import os
+
+import numpy as np
+
+from promptflow.client import PFClient
+from promptflow.tracing import ThreadPoolExecutorWithContext as ThreadPoolExecutor
+
+LOGGER = logging.getLogger(__name__)
+
+
+class ProxyRun:
+    def __init__(self, run, **kwargs):
+        self.run = run
+
+
+class ProxyClient:
+    def __init__(self, pf_client: PFClient):
+        self._pf_client = pf_client
+        self._thread_pool = ThreadPoolExecutor(thread_name_prefix="evaluators_thread")
+
+    def run(self, flow, data, column_mapping=None, **kwargs):
+        flow_to_run = flow
+        if hasattr(flow, "_to_async"):
+            flow_to_run = flow._to_async()
+
+        batch_use_async = self._should_batch_use_async(flow_to_run)
+        eval_future = self._thread_pool.submit(
+            self._pf_client.run,
+            flow_to_run,
+            data=data,
+            column_mapping=column_mapping,
+            batch_use_async=batch_use_async,
+            **kwargs
+        )
+        return ProxyRun(run=eval_future)
+
+    def get_details(self, proxy_run, all_results=False):
+        run = proxy_run.run.result()
+        result_df = self._pf_client.get_details(run, all_results=all_results)
+        result_df.replace("(Failed)", np.nan, inplace=True)
+        return result_df
+
+    def get_metrics(self, proxy_run):
+        run = proxy_run.run.result()
+        return self._pf_client.get_metrics(run)
+
+    @staticmethod
+    def _should_batch_use_async(flow):
+        if os.getenv("PF_EVALS_BATCH_USE_ASYNC", "true").lower() == "true":
+            if hasattr(flow, "__call__") and inspect.iscoroutinefunction(flow.__call__):
+                return True
+            elif inspect.iscoroutinefunction(flow):
+                return True
+            else:
+                return False
+        return False

azure/ai/evaluation/_evaluate/_eval_run.py

@@ -8,20 +8,17 @@ import logging
 import os
 import posixpath
 import time
-import types
 import uuid
-from typing import Any, Dict, List, Optional, Set, Type
+from typing import Any, Dict, Optional, Set
 from urllib.parse import urlparse
 
-from promptflow._sdk.entities import Run
-from typing_extensions import Self
+from azure.core.pipeline.policies import RetryPolicy
+from azure.core.rest import HttpResponse
 
-from azure.ai.evaluation._exceptions import ErrorBlame, ErrorCategory, ErrorTarget, EvaluationException
+from promptflow._sdk.entities import Run
 from azure.ai.evaluation._http_utils import get_http_client
 from azure.ai.evaluation._version import VERSION
-from azure.core.pipeline.policies import RetryPolicy
-from azure.core.rest import HttpResponse
-from azure.core.exceptions import HttpResponseError
+from azure.ai.evaluation._exceptions import EvaluationException, ErrorBlame, ErrorCategory, ErrorTarget
 
 LOGGER = logging.getLogger(__name__)
 
@@ -29,20 +26,18 @@ LOGGER = logging.getLogger(__name__)
 # Handle optional import. The azure libraries are only present if
 # promptflow-azure is installed.
 try:
-    from azure.ai.ml import MLClient
     from azure.ai.ml.entities._credentials import AccountKeyConfiguration  # pylint: disable=ungrouped-imports
     from azure.ai.ml.entities._datastore.datastore import Datastore
     from azure.storage.blob import BlobServiceClient
 except (ModuleNotFoundError, ImportError):
-    raise EvaluationException(  # pylint: disable=raise-missing-from
-        message=(
-            "The required packages for remote tracking are missing.\n"
-            'To resolve this, please install them by running "pip install azure-ai-evaluation[remote]".'
-        ),
-        target=ErrorTarget.EVALUATE,
-        category=ErrorCategory.MISSING_PACKAGE,
-        blame=ErrorBlame.USER_ERROR,
-    )
+    # If the above mentioned modules cannot be imported, we are running
+    # in local mode and MLClient in the constructor will be None, so
+    # we will not arrive to Azure-dependent code.
+
+    # We are logging the import failure only if debug logging level is set because:
+    # - If the project configuration was not provided this import is not needed.
+    # - If the project configuration was provided, the error will be raised by PFClient.
+    LOGGER.debug("promptflow.azure is not installed.")
 
 
 @dataclasses.dataclass
@@ -104,6 +99,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
     _SCOPE = "https://management.azure.com/.default"
 
     EVALUATION_ARTIFACT = "instance_results.jsonl"
+    EVALUATION_ARTIFACT_DUMMY_RUN = "eval_results.jsonl"
 
     def __init__(
         self,
@@ -124,8 +120,8 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         self._run_name = run_name
         self._promptflow_run = promptflow_run
         self._status = RunStatus.NOT_STARTED
-        self._url_base: Optional[str] = None
-        self._info: Optional[RunInfo] = None
+        self._url_base = None
+        self.info = None
 
     @property
     def status(self) -> RunStatus:
@@ -137,20 +133,6 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         """
         return self._status
 
-    @property
-    def info(self) -> RunInfo:
-        if self._info is None:
-            msg = "Run info is missing"
-            raise EvaluationException(
-                message=msg,
-                internal_message=msg,
-                target=ErrorTarget.EVAL_RUN,
-                category=ErrorCategory.UNKNOWN,
-                blame=ErrorBlame.UNKNOWN,
-            )
-
-        return self._info
-
     def _get_scope(self) -> str:
         """
         Return the scope information for the workspace.
@@ -178,14 +160,12 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
             )
             self._url_base = None
             self._status = RunStatus.BROKEN
-            self._info = RunInfo.generate(self._run_name)
+            self.info = RunInfo.generate(self._run_name)
         else:
             self._url_base = urlparse(self._tracking_uri).netloc
             if self._promptflow_run is not None:
-                self._info = RunInfo(
-                    self._promptflow_run.name,
-                    self._promptflow_run._experiment_name,  # pylint: disable=protected-access
-                    self._promptflow_run.name,
+                self.info = RunInfo(
+                    self._promptflow_run.name, self._promptflow_run._experiment_name, self._promptflow_run.name
                 )
             else:
                 url = f"https://{self._url_base}/mlflow/v2.0" f"{self._get_scope()}/api/2.0/mlflow/runs/create"
@@ -199,17 +179,15 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
                     body["run_name"] = self._run_name
                 response = self.request_with_retry(url=url, method="POST", json_dict=body)
                 if response.status_code != 200:
-                    self._info = RunInfo.generate(self._run_name)
+                    self.info = RunInfo.generate(self._run_name)
                     LOGGER.warning(
-                        "The run failed to start: %s: %s."
-                        "The results will be saved locally, but will not be logged to Azure.",
-                        response.status_code,
-                        response.text(),
+                        f"The run failed to start: {response.status_code}: {response.text()}."
+                        "The results will be saved locally, but will not be logged to Azure."
                     )
                     self._status = RunStatus.BROKEN
                 else:
                     parsed_response = response.json()
-                    self._info = RunInfo(
+                    self.info = RunInfo(
                         run_id=parsed_response["run"]["info"]["run_id"],
                         experiment_id=parsed_response["run"]["info"]["experiment_id"],
                         run_name=parsed_response["run"]["info"]["run_name"],
@@ -238,7 +216,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
                 internal_message="Incorrect terminal status. Valid statuses are 'FINISHED', 'FAILED' and 'KILLED'",
                 target=ErrorTarget.EVAL_RUN,
                 category=ErrorCategory.FAILED_EXECUTION,
-                blame=ErrorBlame.UNKNOWN,
+                blame=ErrorBlame.UNKNOWN
             )
         url = f"https://{self._url_base}/mlflow/v2.0" f"{self._get_scope()}/api/2.0/mlflow/runs/update"
         body = {
@@ -252,7 +230,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
             LOGGER.warning("Unable to terminate the run.")
         self._status = RunStatus.TERMINATED
 
-    def __enter__(self) -> Self:
+    def __enter__(self):
         """The Context Manager enter call.
 
         :return: The instance of the class.
@@ -261,21 +239,8 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         self._start_run()
         return self
 
-    def __exit__(
-        self,
-        exc_type: Optional[Type[BaseException]],
-        exc_value: Optional[BaseException],
-        exc_tb: Optional[types.TracebackType],
-    ) -> None:
-        """The context manager exit call.
-
-        :param exc_type: The exception type
-        :type exc_type: Optional[Type[BaseException]]
-        :param exc_value: The exception value
-        :type exc_value: Optional[BaseException]
-        :param exc_tb: The exception traceback
-        :type exc_tb: Optional[types.TracebackType]
-        """
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        """The context manager exit call."""
         self._end_run("FINISHED")
 
     def get_run_history_uri(self) -> str:
@@ -315,7 +280,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         # is an optional dependency.
         from promptflow.azure._utils._token_cache import ArmTokenCache  # pylint: disable=import-error,no-name-in-module
 
-        return ArmTokenCache().get_token(self._ml_client._credential)  # pylint: disable=protected-access
+        return ArmTokenCache().get_token(self._ml_client._credential)
 
     def request_with_retry(
         self, url: str, method: str, json_dict: Dict[str, Any], headers: Optional[Dict[str, str]] = None
@@ -361,10 +326,9 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         :type response: HttpResponse
         """
         LOGGER.warning(
-            "Unable to %s, the request failed with status code %s, response.text()=%s.",
-            failed_op,
-            response.status_code,
-            response.text(),
+            f"Unable to {failed_op}, "
+            f"the request failed with status code {response.status_code}, "
+            f"{response.text()=}."
         )
 
     def _check_state_and_log(self, action: str, bad_states: Set[RunStatus], should_raise: bool) -> bool:
@@ -378,8 +342,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         :type bad_states: Set[RunStatus]
         :param should_raise: Should we raise an error if the bad state has been encountered
         :type should_raise: bool
-        :raises: ~azure.ai.evaluations._exceptions.EvaluationException if should_raise is True
-             and invalid state was encountered.
+        :raises: ~azure.ai.evaluations._exceptions.EvaluationException if should_raise is True and invalid state was encountered.
         :return: Whether or not run is in the correct state.
         :rtype: bool
         """
@@ -391,7 +354,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
                     internal_message=msg,
                     target=ErrorTarget.EVAL_RUN,
                     category=ErrorCategory.FAILED_EXECUTION,
-                    blame=ErrorBlame.UNKNOWN,
+                    blame=ErrorBlame.UNKNOWN
                 )
             LOGGER.warning(msg)
             return False
@@ -413,7 +376,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         """
         if not self._check_state_and_log("log artifact", {RunStatus.BROKEN, RunStatus.NOT_STARTED}, False):
             return
-        # Check if artifact directory is empty or does not exist.
+        # Check if artifact dirrectory is empty or does not exist.
         if not os.path.isdir(artifact_folder):
             LOGGER.warning("The path to the artifact is either not a directory or does not exist.")
             return
@@ -425,7 +388,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
             return
         # First we will list the files and the appropriate remote paths for them.
         root_upload_path = posixpath.join("promptflow", "PromptFlowArtifacts", self.info.run_name)
-        remote_paths: Dict[str, List[Dict[str, str]]] = {"paths": []}
+        remote_paths = {"paths": []}
         local_paths = []
         # Go over the artifact folder and upload all artifacts.
         for root, _, filenames in os.walk(artifact_folder):
@@ -444,32 +407,15 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         datastore = self._ml_client.datastores.get_default(include_secrets=True)
         account_url = f"{datastore.account_name}.blob.{datastore.endpoint}"
         svc_client = BlobServiceClient(account_url=account_url, credential=self._get_datastore_credential(datastore))
-        try:
-            for local, remote in zip(local_paths, remote_paths["paths"]):
-                blob_client = svc_client.get_blob_client(container=datastore.container_name, blob=remote["path"])
-                with open(local, "rb") as fp:
-                    blob_client.upload_blob(fp, overwrite=True)
-        except HttpResponseError as ex:
-            if ex.status_code == 403:
-                msg = (
-                    "Failed to upload evaluation run to the cloud due to insufficient permission to access the storage."
-                    " Please ensure that the necessary access rights are granted."
-                )
-                raise EvaluationException(
-                    message=msg,
-                    target=ErrorTarget.EVAL_RUN,
-                    category=ErrorCategory.FAILED_REMOTE_TRACKING,
-                    blame=ErrorBlame.USER_ERROR,
-                    tsg_link="https://aka.ms/azsdk/python/evaluation/remotetracking/troubleshoot",
-                ) from ex
-
-            raise ex
+        for local, remote in zip(local_paths, remote_paths["paths"]):
+            blob_client = svc_client.get_blob_client(container=datastore.container_name, blob=remote["path"])
+            with open(local, "rb") as fp:
+                blob_client.upload_blob(fp, overwrite=True)
 
         # To show artifact in UI we will need to register it. If it is a promptflow run,
         # we are rewriting already registered artifact and need to skip this step.
         if self._is_promptflow_run:
             return
-
         url = (
             f"https://{self._url_base}/artifact/v2.0/subscriptions/{self._subscription_id}"
             f"/resourceGroups/{self._resource_group_name}/providers/"
@@ -492,29 +438,6 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
         if response.status_code != 200:
             self._log_warning("register artifact", response)
 
-        # register artifacts for images if exists in image folder
-        try:
-            for remote_path in remote_paths["paths"]:
-                remote_file_path = remote_path["path"]
-                if "images" in os.path.normpath(remote_file_path).split(os.sep):
-                    response = self.request_with_retry(
-                        url=url,
-                        method="POST",
-                        json_dict={
-                            "origin": "ExperimentRun",
-                            "container": f"dcid.{self.info.run_id}",
-                            "path": posixpath.join("images", os.path.basename(remote_file_path)),
-                            "dataPath": {
-                                "dataStoreName": datastore.name,
-                                "relativePath": remote_file_path,
-                            },
-                        },
-                    )
-                    if response.status_code != 200:
-                        self._log_warning("register image artifact", response)
-        except Exception as ex:  # pylint: disable=broad-exception-caught
-            LOGGER.debug("Exception occurred while registering image artifact. ex: %s", ex)
-
     def _get_datastore_credential(self, datastore: "Datastore"):
         # Reference the logic in azure.ai.ml._artifact._artifact_utilities
         # https://github.com/Azure/azure-sdk-for-python/blob/main/sdk/ml/azure-ai-ml/azure/ai/ml/_artifacts/_artifact_utilities.py#L103
@@ -523,7 +446,7 @@ class EvalRun(contextlib.AbstractContextManager):  # pylint: disable=too-many-in
             return credential.account_key
         if hasattr(credential, "sas_token"):
             return credential.sas_token
-        return self._ml_client.datastores._credential  # pylint: disable=protected-access
+        return self._ml_client.datastores._credential
 
     def log_metric(self, key: str, value: float) -> None:
         """