enkryptai-sdk 1.0.23__py3-none-any.whl → 1.0.25__py3-none-any.whl

enkryptai_sdk/__init__.py

@@ -7,22 +7,80 @@ from .red_team import RedTeamClient, RedTeamClientError
 from .datasets import DatasetClient, DatasetClientError
 from .deployments import DeploymentClient, DeploymentClientError
 from .ai_proxy import AIProxyClient, AIProxyClientError
+from .utils.pagination import (
+    PaginationInfo,
+    PaginatedResponse,
+    parse_pagination_params,
+    build_pagination_url,
+    create_paginated_response,
+    validate_pagination_params,
+    get_pagination_metadata,
+    calculate_page_info,
+    create_pagination_links,
+    apply_pagination_to_list,
+    format_pagination_response
+)
+
+# Import DTOs
+from .dto.models import (
+    ModelProviders,
+    AuthData,
+    BoxAIAuthData,
+    ModelConfigDetails,
+    DetailModelConfig,
+    ModelDetailConfig,
+    PathsConfig,
+    EndpointConfig,
+    ModelResponse,
+    InputModality,
+    OutputModality
+)
 
 __all__ = [
+    # Clients
     "GuardrailsClient",
     "GuardrailsClientError",
-    "GuardrailsConfig",
-    "CoCClient",
+    "CoCClient", 
     "CoCClientError",
     "EvalsClient",
     "ModelClient",
-    "RedTeamClient",
-    "DatasetClient",
-    "DeploymentClient",
     "ModelClientError",
+    "RedTeamClient",
     "RedTeamClientError",
+    "DatasetClient",
     "DatasetClientError",
+    "DeploymentClient",
     "DeploymentClientError",
     "AIProxyClient",
     "AIProxyClientError",
+    "EvalsClient",
+    
+    # Config
+    "GuardrailsConfig",
+    
+    # Pagination utilities
+    "PaginationInfo",
+    "PaginatedResponse",
+    "parse_pagination_params",
+    "build_pagination_url",
+    "create_paginated_response",
+    "validate_pagination_params",
+    "get_pagination_metadata",
+    "calculate_page_info",
+    "create_pagination_links",
+    "apply_pagination_to_list",
+    "format_pagination_response",
+    
+    # DTOs
+    "ModelProviders",
+    "AuthData",
+    "BoxAIAuthData",
+    "ModelConfigDetails",
+    "DetailModelConfig",
+    "ModelDetailConfig",
+    "PathsConfig",
+    "EndpointConfig",
+    "ModelResponse",
+    "InputModality",
+    "OutputModality"
 ]

enkryptai_sdk/dto/__init__.py

@@ -10,6 +10,7 @@ from .coc import *
 __all__ = [
     "RedteamHealthResponse",
     "RedTeamModelHealthConfig",
+    "RedTeamModelHealthConfigV3",
     "RedteamModelHealthResponse",
     "DetailModelConfig",
     "ModelConfig",
@@ -25,6 +26,14 @@ __all__ = [
     "DEFAULT_REDTEAM_CONFIG_WITH_SAVED_MODEL",
     "DEFAULT_CUSTOM_REDTEAM_CONFIG",
     "DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL",
+    # V3 additions
+    "AttackMethodsV3",
+    "TestConfigV3",
+    "RedTeamTestConfigurationsV3",
+    "RedTeamCustomConfigV3",
+    "RedTeamCustomConfigWithSavedModelV3",
+    "DEFAULT_CUSTOM_REDTEAM_CONFIG_V3",
+    "DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL_V3",
     "ADVANCED_REDTEAM_TESTS",
     "DETAIL_MODEL_CONFIG",
     "DatasetConfig",

enkryptai_sdk/dto/models.py

@@ -42,6 +42,7 @@ class ModelProviders(str, Enum):
     HR = "hr"
     URL = "url"
     ENKRYPTAI = "enkryptai"
+    BOXAI = "boxai"
 
 
 @dataclass
@@ -88,6 +89,44 @@ class AuthData(BaseDTO):
         return cls(**data)
 
 
+@dataclass
+class BoxAIAuthData(AuthData):
+    """BoxAI-specific authentication data."""
+    boxai_client_id: Optional[str] = None
+    boxai_client_secret: Optional[str] = None
+    boxai_user_id: Optional[str] = None
+    boxai_default_file_id: Optional[str] = None
+    
+    def __post_init__(self):
+        # Store BoxAI fields in extra_fields for backward compatibility
+        if self.boxai_client_id:
+            self._extra_fields["boxai_client_id"] = self.boxai_client_id
+        if self.boxai_client_secret:
+            self._extra_fields["boxai_client_secret"] = self.boxai_client_secret
+        if self.boxai_user_id:
+            self._extra_fields["boxai_user_id"] = self.boxai_user_id
+        if self.boxai_default_file_id:
+            self._extra_fields["boxai_default_file_id"] = self.boxai_default_file_id
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        # Extract BoxAI fields from extra_fields if they exist
+        boxai_data = {}
+        if "_extra_fields" in data:
+            extra_fields = data["_extra_fields"]
+            for field in ["boxai_client_id", "boxai_client_secret", "boxai_user_id", "boxai_default_file_id"]:
+                if field in extra_fields:
+                    boxai_data[field] = extra_fields[field]
+        
+        # Merge with direct field values
+        for field in ["boxai_client_id", "boxai_client_secret", "boxai_user_id", "boxai_default_file_id"]:
+            if field in data:
+                boxai_data[field] = data[field]
+        
+        # Create the instance
+        return cls(**boxai_data)
+
+
 @dataclass
 class ModelDetailConfig:
     model_source: str = ""

enkryptai_sdk/dto/red_team.py

@@ -334,10 +334,12 @@ class RedTeamResultDetails(BaseDTO):
 @dataclass
 class AttackMethods(BaseDTO):
     basic: List[str] = field(default_factory=lambda: ["basic"])
-    # advanced: Dict[str, List[str]] = field(
-    #     default_factory=lambda: {"static": ["single_shot"], "dynamic": ["iterative"]}
-    # )
-    advanced: Dict[str, List[str]] = field(default_factory=dict)
+    advanced: Dict[str, List[str]] = field(
+        default_factory=lambda: {
+            "static": ["masking", "figstep", "hades","encoding", "single_shot", "echo", "speed", "pitch", "reverb", "noise" ],
+            "dynamic": ["iterative","jood"]
+        }
+    )
 
     def to_dict(self) -> dict:
         return asdict(self)
@@ -391,6 +393,7 @@ class RedTeamTestConfigurations(BaseDTO):
     # Basic tests
     bias_test: TestConfig = field(default=None)
     cbrn_test: TestConfig = field(default=None)
+    csem_test: TestConfig = field(default=None)
     insecure_code_test: TestConfig = field(default=None)
     toxicity_test: TestConfig = field(default=None)
     harmful_test: TestConfig = field(default=None)
@@ -514,6 +517,60 @@ class RedTeamModelHealthConfig(BaseDTO):
         )
 
 
+@dataclass
+class RedTeamModelHealthConfigV3(BaseDTO):
+    """
+    V3 format for model health check that accepts endpoint_configuration
+    similar to add_custom_task.
+    """
+    endpoint_configuration: ModelConfig = field(
+        default_factory=ModelConfig
+    )
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        endpoint_config = ModelConfig.from_dict(
+            data.pop("endpoint_configuration", {})
+        )
+        return cls(
+            endpoint_configuration=endpoint_config,
+        )
+    
+    def to_target_model_configuration(self) -> TargetModelConfiguration:
+        """
+        Convert endpoint_configuration to target_model_configuration format.
+        This enables the V3 format to be compatible with the existing backend API.
+        """
+        model_config = self.endpoint_configuration.model_config
+        
+        return TargetModelConfiguration(
+            testing_for=self.endpoint_configuration.testing_for,
+            system_prompt=model_config.system_prompt,
+            model_source=model_config.model_source,
+            model_provider=model_config.model_provider.value if hasattr(model_config.model_provider, 'value') else model_config.model_provider,
+            model_endpoint_url=model_config.endpoint_url,
+            rate_per_min=model_config.rate_per_min,
+            model_name=self.endpoint_configuration.model_name,
+            model_version=self.endpoint_configuration.model_version,
+            model_auth_type=model_config.model_auth_type,
+            model_jwt_config=model_config.model_jwt_config,
+            model_api_key=model_config.apikey,
+            input_modalities=[InputModality(m) if isinstance(m, str) else m for m in model_config.input_modalities],
+            output_modalities=[OutputModality(m) if isinstance(m, str) else m for m in model_config.output_modalities],
+            custom_curl_command=model_config.custom_curl_command,
+            custom_headers=model_config.custom_headers,
+            custom_payload=model_config.custom_payload,
+            custom_response_content_type=model_config.custom_response_content_type,
+            custom_response_format=model_config.custom_response_format,
+        )
+
+
 @dataclass
 class RedteamModelHealthResponse(BaseDTO):
     status: str
@@ -609,6 +666,7 @@ class RedTeamConfigWithSavedModel(BaseDTO):
 @dataclass
 class RedTeamCustomConfig(BaseDTO):
     test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
 
     redteam_test_configurations: RedTeamTestConfigurations = field(
         default_factory=RedTeamTestConfigurations
@@ -651,6 +709,7 @@ class RedTeamCustomConfig(BaseDTO):
 @dataclass
 class RedTeamCustomConfigWithSavedModel(BaseDTO):
     test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
 
     redteam_test_configurations: RedTeamTestConfigurations = field(
         default_factory=RedTeamTestConfigurations
@@ -847,6 +906,201 @@ class RedTeamFindingsResponse(BaseDTO):
         return result
 
 
+@dataclass
+class RedTeamDownloadLinkResponse(BaseDTO):
+    link: str = ""
+    expiry: str = ""
+    expires_at: str = ""
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "RedTeamDownloadLinkResponse":
+        return cls(
+            link=data.get("link", ""),
+            expiry=data.get("expiry", ""),
+            expires_at=data.get("expires_at", "")
+        )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        result = {
+            "link": self.link,
+            "expiry": self.expiry,
+            "expires_at": self.expires_at
+        }
+        result.update(self._extra_fields)
+        return result
+
+
+# V3 Attack Methods and Test Configurations
+@dataclass
+class AttackMethodsV3(BaseDTO):
+    """
+    V3 format for attack methods with nested structure:
+    {
+        "method_category": {
+            "method_name": {
+                "params": {}
+            }
+        }
+    }
+    """
+    _data: Dict[str, Dict[str, Dict[str, Any]]] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        return self._data
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(_data=data)
+
+
+@dataclass
+class TestConfigV3(BaseDTO):
+    sample_percentage: int = 5
+    attack_methods: AttackMethodsV3 = field(default_factory=AttackMethodsV3)
+
+    def to_dict(self) -> dict:
+        return {
+            "sample_percentage": self.sample_percentage,
+            "attack_methods": self.attack_methods.to_dict(),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        attack_methods = AttackMethodsV3.from_dict(data.get("attack_methods", {}))
+        return cls(
+            sample_percentage=data.get("sample_percentage", 5),
+            attack_methods=attack_methods
+        )
+
+
+@dataclass
+class RedTeamTestConfigurationsV3(BaseDTO):
+    """V3 format for red team test configurations with nested attack methods"""
+    # Basic tests
+    bias_test: TestConfigV3 = field(default=None)
+    cbrn_test: TestConfigV3 = field(default=None)
+    csem_test: TestConfigV3 = field(default=None)
+    insecure_code_test: TestConfigV3 = field(default=None)
+    toxicity_test: TestConfigV3 = field(default=None)
+    harmful_test: TestConfigV3 = field(default=None)
+    pii_test: TestConfigV3 = field(default=None)
+    copyright_test: TestConfigV3 = field(default=None)
+    misinformation_test: TestConfigV3 = field(default=None)
+    system_prompt_extractions_test: TestConfigV3 = field(default=None)
+    sponge_test: TestConfigV3 = field(default=None)
+    # Advanced tests
+    adv_info_test: TestConfigV3 = field(default=None)
+    adv_bias_test: TestConfigV3 = field(default=None)
+    adv_tool_test: TestConfigV3 = field(default=None)
+    adv_command_test: TestConfigV3 = field(default=None)
+    adv_pii_test: TestConfigV3 = field(default=None)
+    adv_competitor_test: TestConfigV3 = field(default=None)
+    # Custom tests
+    custom_test: TestConfigV3 = field(default=None)
+    # Agents tests
+    alignment_and_governance_test: TestConfigV3 = field(default=None)
+    input_and_content_integrity_test: TestConfigV3 = field(default=None)
+    infrastructure_and_integration_test: TestConfigV3 = field(default=None)
+    security_and_privacy_test: TestConfigV3 = field(default=None)
+    human_factors_and_societal_impact_test: TestConfigV3 = field(default=None)
+    access_control_test: TestConfigV3 = field(default=None)
+    physical_and_actuation_safety_test: TestConfigV3 = field(default=None)
+    reliability_and_monitoring_test: TestConfigV3 = field(default=None)
+    governance_test: TestConfigV3 = field(default=None)
+    agent_output_quality_test: TestConfigV3 = field(default=None)
+    tool_misuse_test: TestConfigV3 = field(default=None)
+    privacy_test: TestConfigV3 = field(default=None)
+    reliability_and_observability_test: TestConfigV3 = field(default=None)
+    agent_behaviour_test: TestConfigV3 = field(default=None)
+    access_control_and_permissions_test: TestConfigV3 = field(default=None)
+    tool_extraction_test: TestConfigV3 = field(default=None)
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**{k: TestConfigV3.from_dict(v) if isinstance(v, dict) else v for k, v in data.items()})
+
+
+@dataclass
+class RedTeamCustomConfigV3(BaseDTO):
+    test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
+
+    redteam_test_configurations: RedTeamTestConfigurationsV3 = field(
+        default_factory=RedTeamTestConfigurationsV3
+    )
+    dataset_configuration: DatasetConfig = field(
+        default_factory=DatasetConfig
+    )
+    endpoint_configuration: ModelConfig = field(
+        default_factory=ModelConfig
+    )
+
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
+        d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        d["endpoint_configuration"] = self.endpoint_configuration.to_dict()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        test_configs = RedTeamTestConfigurationsV3.from_dict(
+            data.pop("redteam_test_configurations", {})
+        )
+        dataset_config = DatasetConfig.from_dict(
+            data.pop("dataset_configuration", {})
+        )
+        endpoint_config = ModelConfig.from_dict(
+            data.pop("endpoint_configuration", {})
+        )
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+            endpoint_configuration=endpoint_config,
+        )
+
+
+@dataclass
+class RedTeamCustomConfigWithSavedModelV3(BaseDTO):
+    test_name: str = "Test Name"
+    frameworks: List[str] = field(default_factory=list)
+
+    redteam_test_configurations: RedTeamTestConfigurationsV3 = field(
+        default_factory=RedTeamTestConfigurationsV3
+    )
+    dataset_configuration: DatasetConfig = field(
+        default_factory=DatasetConfig
+    )
+
+    _extra_fields: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict:
+        d = asdict(self)
+        d["redteam_test_configurations"] = self.redteam_test_configurations.to_dict()
+        d["dataset_configuration"] = self.dataset_configuration.to_dict()
+        return d
+
+    @classmethod
+    def from_dict(cls, data: dict):
+        data = data.copy()
+        test_configs = RedTeamTestConfigurationsV3.from_dict(
+            data.pop("redteam_test_configurations", {})
+        )
+        dataset_config = DatasetConfig.from_dict(
+            data.pop("dataset_configuration", {})
+        )
+        return cls(
+            **data,
+            redteam_test_configurations=test_configs,
+            dataset_configuration=dataset_config,
+        )
+
 
 # Default configurations
 DEFAULT_REDTEAM_CONFIG = RedTeamConfig()
@@ -854,3 +1108,6 @@ DEFAULT_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamConfigWithSavedModel()
 
 DEFAULT_CUSTOM_REDTEAM_CONFIG = RedTeamCustomConfig()
 DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL = RedTeamCustomConfigWithSavedModel()
+
+DEFAULT_CUSTOM_REDTEAM_CONFIG_V3 = RedTeamCustomConfigV3()
+DEFAULT_CUSTOM_REDTEAM_CONFIG_WITH_SAVED_MODEL_V3 = RedTeamCustomConfigWithSavedModelV3()