azure-ai-evaluation 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

azure/ai/evaluation/_red_team/_attack_objective_generator.py

@@ -0,0 +1,192 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import json
+import logging
+import os
+from enum import Enum
+from typing import List, Optional, Dict, Any
+from pathlib import Path
+
+class RiskCategory(str, Enum):
+    """Risk categories for attack objectives."""
+    HateUnfairness = "hate_unfairness"
+    Violence = "violence"
+    Sexual = "sexual"
+    SelfHarm = "self_harm"
+
+class _AttackObjectiveGenerator:
+    """Generator for creating attack objectives.
+
+    :param risk_categories: List of risk categories to generate attack objectives for (optional if custom_attack_seed_prompts is provided)
+    :type risk_categories: Optional[List[RiskCategory]]
+    :param num_objectives: Number of objectives to generate per risk category
+    :type num_objectives: int
+    :param application_scenario: Description of the application scenario for context
+    :type application_scenario: Optional[str]
+    :param custom_attack_seed_prompts: Path to a JSON file containing custom attack seed prompts (can be absolute or relative path)
+    :type custom_attack_seed_prompts: Optional[str]
+    """
+    def __init__(
+        self,
+        risk_categories: Optional[List[RiskCategory]] = None,
+        num_objectives: int = 10,
+        application_scenario: Optional[str] = None,
+        custom_attack_seed_prompts: Optional[str] = None,
+    ):
+        self.risk_categories = risk_categories or []
+        self.num_objectives = num_objectives
+        self.application_scenario = application_scenario
+        self.custom_attack_seed_prompts = custom_attack_seed_prompts
+        self.logger = logging.getLogger("_AttackObjectiveGenerator")
+        
+        # If custom_attack_seed_prompts is provided, validate and load them
+        self.custom_prompts = None
+        self.validated_prompts = []
+        self.valid_prompts_by_category = {}
+        
+        if custom_attack_seed_prompts:
+            self._load_and_validate_custom_prompts()
+            
+    def _load_and_validate_custom_prompts(self) -> None:
+        """Load and validate custom attack seed prompts from the provided file path."""
+        if not self.custom_attack_seed_prompts:
+            return
+            
+        # Handle both absolute and relative paths
+        custom_prompts_path = Path(self.custom_attack_seed_prompts)
+        
+        # Convert to absolute path if it's a relative path
+        if not custom_prompts_path.is_absolute():
+            self.logger.info(f"Converting relative path '{custom_prompts_path}' to absolute path")
+            custom_prompts_path = Path.cwd() / custom_prompts_path
+            
+        self.logger.debug(f"Using absolute path: {custom_prompts_path}")
+        
+        # Check if the file exists
+        if not custom_prompts_path.exists():
+            raise ValueError(f"Custom attack seed prompts file not found: {custom_prompts_path}")
+            
+        try:
+            # Load JSON file
+            with open(custom_prompts_path, 'r', encoding='utf-8') as f:
+                self.custom_prompts = json.load(f)
+                
+            # Validate that it's a list
+            if not isinstance(self.custom_prompts, list):
+                raise ValueError(f"Custom attack seed prompts must be a JSON array, got {type(self.custom_prompts)}, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                
+            self.logger.info(f"Loaded {len(self.custom_prompts)} prompts from {self.custom_attack_seed_prompts}")
+                
+            # Initialize dictionary for categorized prompts
+            for risk_category in RiskCategory:
+                self.valid_prompts_by_category[risk_category.value] = []
+                
+            # Process each prompt and validate format
+            valid_prompts_count = 0
+            invalid_prompts_count = 0
+            for i, prompt in enumerate(self.custom_prompts):
+                try:
+                    # Check required fields
+                    if not isinstance(prompt, dict):
+                        self.logger.warning(f"Skipping prompt {i}: not a JSON object")
+                        continue
+                        
+                    if "metadata" not in prompt:
+                        self.logger.warning(f"Skipping prompt {i}: missing 'metadata' field")
+                        continue
+                        
+                    if "messages" not in prompt or not prompt["messages"]:
+                        self.logger.warning(f"Skipping prompt {i}: missing or empty 'messages' field")
+                        continue
+                        
+                    # Check metadata structure
+                    metadata = prompt["metadata"]
+                    if not isinstance(metadata, dict):
+                        self.logger.warning(f"Skipping prompt {i}: 'metadata' is not a JSON object, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                        
+                    if "target_harms" not in metadata or not metadata["target_harms"]:
+                        self.logger.warning(f"Skipping prompt {i}: missing or empty 'target_harms' in metadata, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                        
+                    # Check target_harms structure
+                    valid_risk_types = {cat.value for cat in RiskCategory}
+                    valid_risk_found = False
+                    prompt_categories = []
+                    
+                    for harm in metadata["target_harms"]:
+                        if not isinstance(harm, dict):
+                            self.logger.warning(f"Skipping harm in prompt {i}: not a JSON object, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                            continue
+                            
+                        if "risk-type" not in harm:
+                            self.logger.warning(f"Skipping harm in prompt {i}: missing 'risk-type' field, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                            continue
+                            
+                        risk_type = harm.get("risk-type", "")
+                        if risk_type not in valid_risk_types:
+                            self.logger.warning(f"Skipping harm in prompt {i}: invalid risk-type '{risk_type}'. Valid types: {valid_risk_types}. see https://aka.ms/airedteamingagent-howtodoc for more information")
+                            continue
+                            
+                        prompt_categories.append(risk_type)
+                        valid_risk_found = True
+                    
+                    if not valid_risk_found:
+                        self.logger.warning(f"Skipping prompt {i}: no valid risk types found. See https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                    
+                    # Check messages structure
+                    messages = prompt["messages"]
+                    if not isinstance(messages, list) or not messages:
+                        self.logger.warning(f"Skipping prompt {i}: 'messages' is not a list or is empty, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                        
+                    message = messages[0]
+                    if not isinstance(message, dict):
+                        self.logger.warning(f"Skipping prompt {i}: first message is not a JSON object, see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                        
+                    if "role" not in message or message["role"] != "user":
+                        self.logger.warning(f"Skipping prompt {i}: first message must have role='user', see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                        
+                    if "content" not in message or not message["content"]:
+                        self.logger.warning(f"Skipping prompt {i}: first message missing or empty 'content', see https://aka.ms/airedteamingagent-howtodoc for more information")
+                        continue
+                    
+                    # If we got here, the prompt is valid
+                    self.validated_prompts.append(prompt)
+                    valid_prompts_count += 1
+                    
+                    # Add to the appropriate categories
+                    for category in prompt_categories:
+                        self.valid_prompts_by_category[category].append(prompt)
+                    
+                except Exception as e:
+                    self.logger.warning(f"Error validating prompt {i}: {str(e)}")
+                    invalid_prompts_count += 1
+                    
+            # Check if we have at least one valid prompt
+            if valid_prompts_count == 0:
+                raise ValueError("No valid prompts found in custom attack seed prompts file. See https://aka.ms/airedteamingagent-howtodoc for more information")
+                
+            self.logger.info(f"Loaded {valid_prompts_count} valid prompts from custom attack seed prompts file")
+            
+            if invalid_prompts_count > 0:
+                self.logger.warning(f"Skipped {invalid_prompts_count} invalid prompts")
+                
+            # Log the breakdown by risk category
+            category_counts = {cat: len(prompts) for cat, prompts in self.valid_prompts_by_category.items() if len(prompts) > 0}
+            self.logger.info(f"Prompt distribution by risk category: {category_counts}")
+            
+            # Automatically extract risk categories from valid prompts if not provided
+            if not self.risk_categories:
+                categories_with_prompts = [cat for cat, prompts in self.valid_prompts_by_category.items() if prompts]
+                self.risk_categories = [RiskCategory(cat) for cat in categories_with_prompts]
+                self.logger.info(f"Automatically set risk categories based on valid prompts: {[cat.value for cat in self.risk_categories]}")
+            
+        except json.JSONDecodeError as e:
+            raise ValueError(f"Failed to parse custom attack seed prompts file: {str(e)}. See https://aka.ms/airedteamingagent-howtodoc for more information")
+        except Exception as e:
+            raise ValueError(f"Error loading custom attack seed prompts: {str(e)}. See https://aka.ms/airedteamingagent-howtodoc for more information")

azure/ai/evaluation/_red_team/_attack_strategy.py

@@ -0,0 +1,42 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+from enum import Enum
+from typing import List
+
+class AttackStrategy(Enum):
+    """Strategies for attacks."""
+    EASY = "easy"
+    MODERATE = "moderate"
+    DIFFICULT = "difficult"
+    AnsiAttack = "ansi_attack"
+    AsciiArt = "ascii_art"
+    AsciiSmuggler = "ascii_smuggler"
+    Atbash = "atbash"
+    Base64 = "base64"
+    Binary = "binary"
+    Caesar = "caesar"
+    CharacterSpace = "character_space"
+    CharSwap = "char_swap"
+    Diacritic = "diacritic"
+    Flip = "flip"
+    Leetspeak = "leetspeak"
+    Morse = "morse"
+    ROT13 = "rot13"
+    SuffixAppend = "suffix_append"
+    StringJoin = "string_join"
+    Tense = "tense"
+    UnicodeConfusable = "unicode_confusable"
+    UnicodeSubstitution = "unicode_substitution"
+    Url = "url"
+    Baseline = "baseline"
+    Jailbreak = "jailbreak"
+
+    @classmethod
+    def Compose(cls, items: List["AttackStrategy"]) -> List["AttackStrategy"]:
+        for item in items:
+            if not isinstance(item, cls):
+                raise ValueError("All items must be instances of AttackStrategy")
+        if len(items) > 2: 
+            raise ValueError("Composed strategies must have at most 2 items")
+        return items

azure/ai/evaluation/_red_team/_callback_chat_target.py

@@ -0,0 +1,74 @@
+# ---------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# ---------------------------------------------------------
+import logging
+from typing import Any, Callable, Dict, List, Optional
+
+from pyrit.models import (
+    PromptRequestResponse,
+    construct_response_from_request,
+)
+from pyrit.prompt_target import PromptChatTarget
+
+logger = logging.getLogger(__name__)
+
+
+class _CallbackChatTarget(PromptChatTarget):
+    def __init__(
+        self,
+        *,
+        callback: Callable[[List[Dict], bool, Optional[str], Optional[Dict[str, Any]]], Dict],
+        stream: bool = False,
+    ) -> None:
+        """
+        Initializes an instance of the _CallbackChatTarget class.
+
+        It is intended to be used with PyRIT where users define a callback function
+        that handles sending a prompt to a target and receiving a response.
+        The _CallbackChatTarget class is a wrapper around the callback function that allows it to be used
+        as a target in the PyRIT framework.
+        For that reason, it merely handles additional functionality such as memory.
+
+        Args:
+            callback (Callable): The callback function that sends a prompt to a target and receives a response.
+            stream (bool, optional): Indicates whether the target supports streaming. Defaults to False.
+        """
+        PromptChatTarget.__init__(self)
+        self._callback = callback
+        self._stream = stream
+
+    async def send_prompt_async(self, *, prompt_request: PromptRequestResponse) -> PromptRequestResponse:
+
+        self._validate_request(prompt_request=prompt_request)
+        request = prompt_request.request_pieces[0]
+
+        messages = self._memory.get_chat_messages_with_conversation_id(conversation_id=request.conversation_id)
+
+        messages.append(request.to_chat_message())
+
+        logger.info(f"Sending the following prompt to the prompt target: {request}")
+
+        # response_context contains "messages", "stream", "session_state, "context"
+        response_context = await self._callback(messages=messages, stream=self._stream, session_state=None, context=None) # type: ignore
+
+        response_text = response_context["messages"][-1]["content"]
+        response_entry = construct_response_from_request(
+            request=request, response_text_pieces=[response_text]
+        )
+
+        logger.info(
+            "Received the following response from the prompt target"
+            + f"{response_text}"
+        )
+        return response_entry
+
+    def _validate_request(self, *, prompt_request: PromptRequestResponse) -> None:
+        if len(prompt_request.request_pieces) != 1:
+            raise ValueError("This target only supports a single prompt request piece.")
+
+        if prompt_request.request_pieces[0].converted_value_data_type != "text":
+            raise ValueError("This target only supports text prompt input.")
+
+    def is_json_response_supported(self) -> bool:
+        """Indicates that this target supports JSON response format."""
+        return False

azure/ai/evaluation/_red_team/_default_converter.py

@@ -0,0 +1,21 @@
+from pyrit.models import PromptDataType
+from pyrit.prompt_converter import ConverterResult, PromptConverter
+
+
+class _DefaultConverter(PromptConverter):
+
+    async def convert_async(self, *, prompt: str, input_type: PromptDataType = "text") -> ConverterResult:
+        """
+        Simple converter that does nothing to the prompt and returns it as is.
+        """
+        if not self.input_supported(input_type):
+            raise ValueError("Input type not supported")
+
+        result = ConverterResult(output_text=prompt, output_type="text")
+        return result
+
+    def input_supported(self, input_type: PromptDataType) -> bool:
+        return input_type == "text"
+
+    def output_supported(self, output_type: PromptDataType) -> bool:
+        return output_type == "text"