Tox black code reformatting

Fix "tox -e black" formatting issues

Author: ralph-msft

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/__init__.py

@@ -64,5 +64,5 @@
     "EvaluatorConfig",
     "Conversation",
     "Message",
-    "EvaluationResult"
+    "EvaluationResult",
 ]

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/_azure/_models.py

@@ -52,7 +52,7 @@ class Workspace(Model):
         "agents_endpoint_uri": {"readonly": True},
         "ml_flow_tracking_uri": {"readonly": True},
         #'notebook_info': {'readonly': True},
-        #"private_endpoint_connections": {"readonly": True},
+        # "private_endpoint_connections": {"readonly": True},
         #'private_link_count': {'readonly': True},
         "provisioning_state": {"readonly": True},
         "service_provisioned_resource_group": {"readonly": True},
@@ -99,10 +99,10 @@ class Workspace(Model):
         #'network_acls': {'key': 'properties.networkAcls', 'type': 'NetworkAcls'},
         #'notebook_info': {'key': 'properties.notebookInfo', 'type': 'NotebookResourceInfo'},
         "primary_user_assigned_identity": {"key": "properties.primaryUserAssignedIdentity", "type": "str"},
-        #"private_endpoint_connections": {
+        # "private_endpoint_connections": {
         #    "key": "properties.privateEndpointConnections",
         #    "type": "[PrivateEndpointConnection]",
-        #},
+        # },
         "private_link_count": {"key": "properties.privateLinkCount", "type": "int"},
         "provision_network_now": {"key": "properties.provisionNetworkNow", "type": "bool"},
         "provisioning_state": {"key": "properties.provisioningState", "type": "str"},

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/_evaluate/_evaluate.py

@@ -486,8 +486,10 @@ def _apply_target_to_data(
     run_summary = batch_client.get_run_summary(run)
 
     if run_summary["completed_lines"] == 0:
-        msg = (f"Evaluation target failed to produce any results."
-               f" Please check the logs at {run_summary['log_path']} for more details about cause of failure.")
+        msg = (
+            f"Evaluation target failed to produce any results."
+            f" Please check the logs at {run_summary['log_path']} for more details about cause of failure."
+        )
         raise EvaluationException(
             message=msg,
             target=ErrorTarget.EVALUATE,

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/_safety_evaluation/_safety_evaluation.py

@@ -224,7 +224,7 @@ async def __call__(
         # Prepare task parameters based on scenario - but use a single append call for all scenarios
         tasks = []
         template_parameter_pairs = []
-        
+
         if scenario == AdversarialScenario.ADVERSARIAL_CONVERSATION:
             # For ADVERSARIAL_CONVERSATION, flatten the parameters
             for i, template in enumerate(templates):
@@ -236,20 +236,20 @@ async def __call__(
             # Use original logic for other scenarios - zip parameters
             parameter_lists = [t.template_parameters for t in templates]
             zipped_parameters = list(zip(*parameter_lists))
-            
+
             for param_group in zipped_parameters:
                 for template, parameter in zip(templates, param_group):
                     template_parameter_pairs.append((template, parameter))
 
         # Limit to max_simulation_results if needed
         if len(template_parameter_pairs) > max_simulation_results:
             template_parameter_pairs = template_parameter_pairs[:max_simulation_results]
-        
+
         # Single task append loop for all scenarios
         for template, parameter in template_parameter_pairs:
             if _jailbreak_type == "upia":
                 parameter = self._add_jailbreak_parameter(parameter, random.choice(jailbreak_dataset))
-            
+
             tasks.append(
                 asyncio.create_task(
                     self._simulate_async(
@@ -326,7 +326,11 @@ async def _simulate_async(
         simulation_id: str = "",
     ) -> List[Dict]:
         user_bot = self._setup_bot(
-            role=ConversationRole.USER, template=template, parameters=parameters, scenario=scenario, simulation_id=simulation_id
+            role=ConversationRole.USER,
+            template=template,
+            parameters=parameters,
+            scenario=scenario,
+            simulation_id=simulation_id,
         )
         system_bot = self._setup_bot(
             target=target, role=ConversationRole.ASSISTANT, template=template, parameters=parameters, scenario=scenario
@@ -381,7 +385,9 @@ def _setup_bot(
     ) -> ConversationBot:
         if role is ConversationRole.USER:
             model = self._get_user_proxy_completion_model(
-                template_key=template.template_name, template_parameters=parameters, simulation_id=simulation_id,
+                template_key=template.template_name,
+                template_parameters=parameters,
+                simulation_id=simulation_id,
             )
             return ConversationBot(
                 role=role,

sdk/evaluation/azure-ai-evaluation/azure/ai/evaluation/simulator/_adversarial_simulator.py

@@ -71,7 +71,7 @@
         "azure-identity>=1.16.0",
         "azure-core>=1.30.2",
         "nltk>=3.9.1",
-        "azure-storage-blob>=12.10.0"
+        "azure-storage-blob>=12.10.0",
     ],
     project_urls={
         "Bug Reports": "https://github.com/Azure/azure-sdk-for-python/issues",

sdk/evaluation/azure-ai-evaluation/setup.py

@@ -34,6 +34,7 @@ def questions_file():
     data_path = os.path.join(pathlib.Path(__file__).parent.resolve(), "data")
     return os.path.join(data_path, "questions.jsonl")
 
+
 def answer_evaluator(response):
     return {"length": len(response)}
 

sdk/evaluation/azure-ai-evaluation/tests/e2etests/test_evaluate.py

@@ -73,7 +73,7 @@ class TestMassEvaluate:
     - Conversation inputs: Where a conversation is inputted and the relevant inputs are extracted.
     - Multi-modal inputs: This one has some parameters for the different types of multi-modal inputs.
     """
-    
+
     @pytest.mark.skipif(not is_live(), reason="Skip in playback due to inconsistency in evaluation results.")
     def test_evaluate_singleton_inputs(self, model_config, azure_cred, project_scope, data_file):
         # qa fails in playback but ONLY when using the pf proxy for some reason, and

sdk/evaluation/azure-ai-evaluation/tests/e2etests/test_mass_evaluate.py

@@ -118,9 +118,11 @@ def _target_fn2(query):
     response["query"] = f"The query is as follows: {query}"
     return response
 
+
 def _target_that_fails(query):
     raise Exception("I am failing")
 
+
 def _new_answer_target():
     return {"response": "new response"}
 
@@ -390,7 +392,7 @@ def test_apply_column_mapping_target(self, json_data, inputs_mapping, response):
             {"query": "${data.query"},
             {"query": "data.query", "response": "target.response"},
             {"query": "${data.query}", "response": "${target.response.one}"},
-        ]
+        ],
     )
     def test_evaluate_invalid_column_mapping(self, mock_model_config, evaluate_test_data_jsonl_file, column_mapping):
         # Invalid source reference
@@ -402,12 +404,12 @@ def test_evaluate_invalid_column_mapping(self, mock_model_config, evaluate_test_
                     "g": {
                         "column_mapping": column_mapping,
                     }
-                }
+                },
             )
 
         assert (
-                "Unexpected references detected in 'column_mapping'. Ensure only ${target.} and ${data.} are used."
-                in exc_info.value.args[0]
+            "Unexpected references detected in 'column_mapping'. Ensure only ${target.} and ${data.} are used."
+            in exc_info.value.args[0]
         )
 
     def test_renaming_column(self):

sdk/evaluation/azure-ai-evaluation/tests/unittests/test_evaluate.py

@@ -7,10 +7,12 @@
 from azure.ai.evaluation.simulator._utils import JsonLineChatProtocol, JsonLineList
 from azure.core.credentials import TokenCredential
 
+
 @pytest.fixture
 def mock_credential():
     return MagicMock(spec=TokenCredential)
 
+
 @pytest.fixture
 def mock_model_config_dict_valid():
     return {
@@ -19,51 +21,58 @@ def mock_model_config_dict_valid():
         "type": "azure_openai",
     }
 
+
 @pytest.fixture
 def mock_model_config_dict_invalid():
     return {
         "type": "azure_openai",
     }
 
+
 @pytest.fixture
 def mock_target():
     def mock_target_fn() -> str:
         return "mock response"
+
     return mock_target_fn
 
+
 @pytest.fixture
 def mock_target_with_context():
     def mock_target_with_context_fn() -> tuple:
         return ("mock response", "mock context")
+
     return mock_target_with_context_fn
 
+
 @pytest.fixture
 def mock_eval_result_dict():
     jailbreak = {
-        'rows': [
+        "rows": [
             {
-                'outputs.content_safety.hate_unfairness_score': 0.0,
-                'outputs.content_safety.self_harm_score': 0.0,
-                'outputs.content_safety.sexual_score': 0.0,
-                'outputs.content_safety.violence_score': 0.0,
+                "outputs.content_safety.hate_unfairness_score": 0.0,
+                "outputs.content_safety.self_harm_score": 0.0,
+                "outputs.content_safety.sexual_score": 0.0,
+                "outputs.content_safety.violence_score": 0.0,
             }
         ],
-        'metrics': {},
-        'studio_url': 'some url'
+        "metrics": {},
+        "studio_url": "some url",
     }
     regular = {
-        'rows': [
+        "rows": [
             {
-                'outputs.content_safety.hate_unfairness_score': 0.0,
-                'outputs.content_safety.self_harm_score': 0.0,
-                'outputs.content_safety.sexual_score': 0.0,
-                'outputs.content_safety.violence_score': 0.0,
+                "outputs.content_safety.hate_unfairness_score": 0.0,
+                "outputs.content_safety.self_harm_score": 0.0,
+                "outputs.content_safety.sexual_score": 0.0,
+                "outputs.content_safety.violence_score": 0.0,
             }
         ],
-        'metrics': {},
-        'studio_url': 'some url'
+        "metrics": {},
+        "studio_url": "some url",
     }
-    return {'jailbreak': jailbreak , 'regular': regular} 
+    return {"jailbreak": jailbreak, "regular": regular}
+
 
 @pytest.fixture
 def safety_eval(mock_model_config_dict_valid, mock_credential):
@@ -73,13 +82,15 @@ def safety_eval(mock_model_config_dict_valid, mock_credential):
         model_config=mock_model_config_dict_valid,
     )
 
+
 @pytest.fixture
 def safety_eval_no_model_config(mock_credential):
     return _SafetyEvaluation(
         azure_ai_project={"subscription_id": "mock-sub", "resource_group_name": "mock-rg", "project_name": "mock-proj"},
         credential=mock_credential,
     )
 
+
 @pytest.mark.usefixtures("mock_model_config")
 @pytest.mark.unittest
 class TestSafetyEvaluation:
@@ -91,7 +102,7 @@ def test_validate_model_config_missing_keys(self, mock_credential, mock_model_co
                 model_config=mock_model_config_dict_invalid,
             )
         assert "missing required keys" in str(exc_info.value)
-    
+
     def test_get_evaluators_invalid(self, safety_eval):
         with pytest.raises(EvaluationException) as exc_info:
             safety_eval._get_evaluators([None])  # type: ignore
@@ -116,12 +127,11 @@ def test_validate_inputs_groundedness_no_source(self, safety_eval, mock_target):
                 source_text=None,
             )
         assert "requires either source_text" in str(exc_info.value)
-    
+
     def test_validate_inputs_multi_turn_scenario(self, safety_eval, mock_target):
         with pytest.raises(EvaluationException) as exc_info:
             safety_eval._validate_inputs(
                 target=mock_target,
-
                 evaluators=[_SafetyEvaluator.CONTENT_SAFETY],
                 scenario=AdversarialScenario.ADVERSARIAL_SUMMARIZATION,
                 num_turns=3,
@@ -135,8 +145,7 @@ def test_validate_inputs_no_model_config(self, safety_eval_no_model_config, mock
                 evaluators=[_SafetyEvaluator.COHERENCE],
             )
         assert "Model configuration is required" in str(exc_info.value)
-    
-    
+
     def test_validate_inputs_scenario_not_content_safety(self, safety_eval, mock_target):
         with pytest.raises(EvaluationException) as exc_info:
             safety_eval._validate_inputs(
@@ -145,17 +154,17 @@ def test_validate_inputs_scenario_not_content_safety(self, safety_eval, mock_tar
                 scenario=AdversarialScenario.ADVERSARIAL_SUMMARIZATION,
             )
         assert "not supported without content safety evaluation" in str(exc_info.value)
-    
+
     def test_calculate_defect_rate(self, safety_eval, mock_eval_result_dict):
         eval_result = safety_eval._calculate_defect_rate(mock_eval_result_dict)
         assert eval_result is not None
-        assert isinstance(eval_result['metrics']['content_safety.violence_defect_rate'], float)
-        assert eval_result['metrics']['content_safety.violence_defect_rate'] == 0.0
-    
+        assert isinstance(eval_result["metrics"]["content_safety.violence_defect_rate"], float)
+        assert eval_result["metrics"]["content_safety.violence_defect_rate"] == 0.0
+
     @pytest.mark.asyncio
     @patch("azure.ai.evaluation.simulator._simulator.Simulator.__call__", new_callable=AsyncMock)
     async def test_simulate_no_scenario(self, mock__call__, safety_eval, mock_target):
-        mock__call__.return_value = [JsonLineChatProtocol({"messages":[]})]
+        mock__call__.return_value = [JsonLineChatProtocol({"messages": []})]
         results = await safety_eval._simulate(target=mock_target)
         assert isinstance(results, dict)
         assert isinstance(results["regular"], str)
@@ -164,27 +173,26 @@ async def test_simulate_no_scenario(self, mock__call__, safety_eval, mock_target
     @patch("azure.ai.evaluation.simulator.DirectAttackSimulator.__init__", return_value=None)
     @patch("azure.ai.evaluation.simulator.DirectAttackSimulator.__call__", new_callable=AsyncMock)
     async def test_simulate_direct_attack(self, mock_call, mock_init, safety_eval, mock_target):
-        mock_call.return_value = {"jailbreak":JsonLineList([{"messages": []}]),"regular":JsonLineList([{"messages": []}])}
+        mock_call.return_value = {
+            "jailbreak": JsonLineList([{"messages": []}]),
+            "regular": JsonLineList([{"messages": []}]),
+        }
 
         results = await safety_eval._simulate(
-            target=mock_target,
-            direct_attack=True,
-            adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
+            target=mock_target, direct_attack=True, adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
         )
         assert isinstance(results, dict)
         assert isinstance(results["regular"], str)
         assert isinstance(results["jailbreak"], str)
 
-
     @pytest.mark.asyncio
     @patch("azure.ai.evaluation.simulator.IndirectAttackSimulator.__init__", return_value=None)
     @patch("azure.ai.evaluation.simulator.IndirectAttackSimulator.__call__", new_callable=AsyncMock)
     async def test_simulate_indirect_jailbreak(self, mock_call, mock_init, safety_eval, mock_target):
-        mock_call.return_value = JsonLineList([{"messages":[]}])
+        mock_call.return_value = JsonLineList([{"messages": []}])
 
         results = await safety_eval._simulate(
-            target=mock_target,
-            adversarial_scenario=AdversarialScenarioJailbreak.ADVERSARIAL_INDIRECT_JAILBREAK
+            target=mock_target, adversarial_scenario=AdversarialScenarioJailbreak.ADVERSARIAL_INDIRECT_JAILBREAK
         )
         assert isinstance(results, dict)
         assert isinstance(results["regular"], str)
@@ -193,10 +201,9 @@ async def test_simulate_indirect_jailbreak(self, mock_call, mock_init, safety_ev
     @patch("azure.ai.evaluation.simulator.AdversarialSimulator.__init__", return_value=None)
     @patch("azure.ai.evaluation.simulator.AdversarialSimulator.__call__", new_callable=AsyncMock)
     async def test_simulate_adversarial(self, mock_call, mock_init, safety_eval, mock_target):
-        mock_call.return_value = JsonLineList([{"messages":[]}])
+        mock_call.return_value = JsonLineList([{"messages": []}])
         results = await safety_eval._simulate(
-            target=mock_target,
-            adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
+            target=mock_target, adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
         )
         assert isinstance(results, dict)
         assert isinstance(results["regular"], str)
@@ -209,7 +216,6 @@ async def test_simulate_no_results(self, mock_call, mock_init, safety_eval, mock
         mock_call.return_value = None
         with pytest.raises(EvaluationException) as exc_info:
             results = await safety_eval._simulate(
-                target=mock_target,
-                adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
+                target=mock_target, adversarial_scenario=AdversarialScenario.ADVERSARIAL_QA
             )
-        assert "outputs generated by the simulator" in str(exc_info.value)
+        assert "outputs generated by the simulator" in str(exc_info.value)