enkryptai-sdk 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

enkryptai_sdk/guardrails.py

@@ -27,13 +27,15 @@ class GuardrailsClient:
         headers = headers or {}
         if 'apikey' not in headers:
             headers['apikey'] = self.api_key
-
-        response = self.session.request(method, url, headers=headers, **kwargs)
-        response.raise_for_status()
+            
         try:
+            response = self.session.request(method, url, headers=headers, **kwargs)
+            response.raise_for_status()
             return response.json()
-        except ValueError:
-            return response.text
+        
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}
 
     # ----------------------------
     # Basic Guardrails Endpoints
@@ -57,36 +59,43 @@ class GuardrailsClient:
         """
         return self._request("GET", "/guardrails/models")
 
-    def detect(self, text, guardrails_config):
+    def detect(self, text, config=None):
         """
         Detects prompt injection, toxicity, NSFW content, PII, hallucination, and more.
 
         Parameters:
         - text (str): The text to analyze.
-        - guardrails_config (dict or GuardrailsConfig): A configuration for detectors.
+        - guardrails_config (dict or GuardrailsConfig, optional): A configuration for detectors.
           If a GuardrailsConfig instance is provided, its underlying dictionary will be used.
+          If not provided, defaults to injection attack detection only.
 
         Returns:
         - JSON response from the API.
         """
+        # Use injection attack config by default if none provided
+        if config is None:
+            from .guardrails_config import GuardrailsConfig
+            config = GuardrailsConfig.injection_attack()
+
         # Allow passing in either a dict or a GuardrailsConfig instance.
-        if hasattr(guardrails_config, "as_dict"):
-            guardrails_config = guardrails_config.as_dict()
+        if hasattr(config, "as_dict"):
+            config = config.as_dict()
             
         payload = {
             "text": text,
-            "detectors": guardrails_config
+            "detectors": config
         }
         return self._request("POST", "/guardrails/detect", json=payload)
 
-    def pii(self, text, mode, key="null"):
+    def pii(self, text, mode, key="null", entities=None):
         """
         Detects Personally Identifiable Information (PII) and can de-anonymize it.
         """
         payload = {
             "text": text,
             "mode": mode,
-            "key": key
+            "key": key,
+            "entities": entities
         }
         return self._request("POST", "/guardrails/pii", json=payload)
 
@@ -94,47 +103,86 @@ class GuardrailsClient:
     # Guardrails Policy Endpoints
     # ----------------------------
 
-    def add_policy(self, name, description, guardrails_config):
+    def add_policy(self, name, config, description="guardrails policy"):
         """
         Create a new policy with custom configurations.
-        """
+        
+        Args:
+            name (str): Name of the policy
+            config (dict or GuardrailsConfig): Configuration for the policy detectors.
+                If a GuardrailsConfig instance is provided, its underlying dictionary will be used.
+            description (str, optional): Description of the policy. Defaults to "guardrails policy"
+        """
+        # Allow passing in either a dict or a GuardrailsConfig instance
+        if hasattr(config, "as_dict"):
+            config = config.as_dict()
+            
         payload = {
             "name": name,
             "description": description,
-            "detectors": guardrails_config
+            "detectors": config
         }
-        return self._request("POST", "/guardrails/add-policy", json=payload)
+        
+        try:
+            return self._request("POST", "/guardrails/add-policy", json=payload)
+        
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}
 
-    def get_policy(self, x_enkrypt_policy):
+    def get_policy(self, policy_name):
         """
         Retrieve an existing policy by providing its header identifier.
         """
-        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
-        return self._request("GET", "/guardrails/get-policy", headers=headers)
+        headers = {"X-Enkrypt-Policy": policy_name}
+        try:
+            return self._request("GET", "/guardrails/get-policy", headers=headers)
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}
 
-    def modify_policy(self, x_enkrypt_policy, name, description, guardrails_config):
+    def modify_policy(self, policy_name, config, name=None, description="guardrails policy"):
         """
         Modify an existing policy.
         """
-        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
+        # Allow passing in either a dict or a GuardrailsConfig instance
+        if hasattr(config, "as_dict"):
+            config = config.as_dict()
+            
+        if name is None:
+            name = policy_name
+            
+        headers = {"X-Enkrypt-Policy": policy_name}
         payload = {
+            "detectors": config,
             "name": name,
-            "description": description,
-            "detectors": guardrails_config
+            "description": description
         }
-        return self._request("PATCH", "/guardrails/modify-policy", headers=headers, json=payload)
+        try:
+            return self._request("PATCH", "/guardrails/modify-policy", headers=headers, json=payload)
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}
 
-    def delete_policy(self, x_enkrypt_policy):
+    def delete_policy(self, policy_name):
         """
         Delete a policy.
         """
-        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
-        return self._request("DELETE", "/guardrails/delete-policy", headers=headers)
+        headers = {"X-Enkrypt-Policy": policy_name}
+        try:
+            return self._request("DELETE", "/guardrails/delete-policy", headers=headers)
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}
 
-    def policy_detect(self, x_enkrypt_policy, text):
+    def policy_detect(self, policy_name, text):
         """
         Apply a specific policy to detect and filter content.
         """
-        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
+        headers = {"X-Enkrypt-Policy": policy_name}
         payload = {"text": text}
-        return self._request("POST", "/guardrails/policy/detect", headers=headers, json=payload)
+        try:
+            return self._request("POST", "/guardrails/policy/detect", headers=headers, json=payload)
+        except Exception as e:
+            print(e)
+            return {"error": str(e)}

enkryptai_sdk/guardrails_config.py

@@ -32,12 +32,13 @@ class GuardrailsConfig:
         Returns a configuration instance pre-configured for injection attack detection.
         """
         config = copy.deepcopy(DEFAULT_CONFIG)
-        config["topic_detector"] = {"enabled": True, "topic": ["injection attack"]}
         config["injection_attack"] = {"enabled": True}
         return cls(config)
 
     @classmethod
-    def policy_violation(cls, policy_text: str, need_explanation: bool = False):
+    def policy_violation(cls, 
+                         policy_text: str, 
+                         need_explanation: bool = False):
         """
         Returns a configuration instance pre-configured for policy violation detection.
         """
@@ -48,6 +49,102 @@ class GuardrailsConfig:
                                       }
         return cls(config)
 
+    @classmethod
+    def toxicity(cls):
+        """
+        Returns a configuration instance pre-configured for toxicity detection.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["toxicity"] = {"enabled": True}
+        return cls(config)
+
+    @classmethod
+    def nsfw(cls):
+        """
+        Returns a configuration instance pre-configured for NSFW content detection.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["nsfw"] = {"enabled": True}
+        return cls(config)
+
+    @classmethod
+    def bias(cls):
+        """
+        Returns a configuration instance pre-configured for bias detection.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["bias"] = {"enabled": True}
+        return cls(config)
+
+    @classmethod
+    def pii(cls, entities=None):
+        """
+        Returns a configuration instance pre-configured for PII detection.
+        
+        Args:
+            entities (list, optional): List of PII entity types to detect.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["pii"] = {
+            "enabled": True,
+            "entities": entities if entities is not None else []
+        }
+        return cls(config)
+
+    @classmethod
+    def topic(cls, topics=None):
+        """
+        Returns a configuration instance pre-configured for topic detection.
+        
+        Args:
+            topics (list, optional): List of topics to detect.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["topic_detector"] = {
+            "enabled": True,
+            "topic": topics if topics is not None else []
+        }
+        return cls(config)
+
+    @classmethod
+    def keyword(cls, keywords=None):
+        """
+        Returns a configuration instance pre-configured for keyword detection.
+        
+        Args:
+            keywords (list, optional): List of banned keywords to detect.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["keyword_detector"] = {
+            "enabled": True,
+            "banned_keywords": keywords if keywords is not None else []
+        }
+        return cls(config)
+
+    @classmethod
+    def copyright_ip(cls):
+        """
+        Returns a configuration instance pre-configured for copyright/IP detection.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["copyright_ip"] = {"enabled": True}
+        return cls(config)
+
+    @classmethod
+    def system_prompt(cls, index="system"):
+        """
+        Returns a configuration instance pre-configured for system prompt detection.
+        
+        Args:
+            index (str, optional): Index name for system prompt detection. Defaults to "system".
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["system_prompt"] = {
+            "enabled": True,
+            "index": index
+        }
+        return cls(config)
+
     def update(self, **kwargs):
         """
         Update the configuration with custom values.
@@ -68,3 +165,57 @@ class GuardrailsConfig:
         Return the underlying configuration dictionary.
         """
         return self.config
+
+    @classmethod
+    def from_custom_config(cls, config_dict: dict):
+        """
+        Configure guardrails from a dictionary input.
+        
+        Validates that the input dictionary matches the expected schema structure.
+        Each key must exist in the default configuration, and its value must be a dictionary.
+        
+        Args:
+            config_dict (dict): Dictionary containing guardrails configuration
+            
+        Returns:
+            GuardrailsConfig: Returns a new GuardrailsConfig instance
+            
+        Raises:
+            ValueError: If the input dictionary contains invalid keys or malformed values
+        """
+        instance = cls()
+        for key, value in config_dict.items():
+            if key not in instance.config:
+                raise ValueError(f"Unknown detector config: {key}")
+            if not isinstance(value, dict):
+                raise ValueError(f"Config value for {key} must be a dictionary")
+            
+            # Validate that all required fields exist in the default config
+            default_fields = set(DEFAULT_CONFIG[key].keys())
+            provided_fields = set(value.keys())
+            
+            if not provided_fields.issubset(default_fields):
+                invalid_fields = provided_fields - default_fields
+                raise ValueError(f"Invalid fields for {key}: {invalid_fields}")
+                
+            instance.config[key] = value
+            
+        return instance
+
+    def get_config(self, detector_name: str) -> dict:
+        """
+        Get the configuration for a specific detector.
+        
+        Args:
+            detector_name (str): Name of the detector to get configuration for
+            
+        Returns:
+            dict: Configuration dictionary for the specified detector
+            
+        Raises:
+            ValueError: If the detector name doesn't exist in the configuration
+        """
+        if detector_name not in self.config:
+            raise ValueError(f"Unknown detector: {detector_name}")
+            
+        return copy.deepcopy(self.config[detector_name])

{enkryptai_sdk-0.1.1.dist-info → enkryptai_sdk-0.1.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: enkryptai-sdk
-Version: 0.1.1
+Version: 0.1.3
 Summary: A Python SDK with guardrails and red teaming functionality for API interactions
 Home-page: https://github.com/enkryptai/enkryptai-sdk
 Author: Enkrypt AI Team
@@ -68,7 +68,98 @@ config = GuardrailsConfig.policy_violation(policy_text="You must not use hate sp
 config = GuardrailsConfig.topic_detection(topic="finance")
 ```
 
+## Policy Management
 
+Policies allow you to save and reuse guardrails configurations.
+
+### Create a Policy
+
+```python
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+client = GuardrailsClient(api_key="your_api_key")
+
+# Create a policy with injection attack detection
+injection_config = GuardrailsConfig.injection_attack()
+client.add_policy(
+    name="my-security-policy",
+    config=injection_config,
+    description="Detects prompt injection attacks"
+)
+
+# Create a policy with multiple detectors
+custom_config = GuardrailsConfig.from_custom_config({
+    "injection_attack": {"enabled": True},
+    "bias": {"enabled": True},
+    "policy_violation": {
+        "enabled": True,
+        "policy_text": "No discussion of hacking allowed",
+        "need_explanation": True
+    }
+})
+
+client.add_policy(
+    name="my-custom-policy",
+    config=custom_config,
+    description="Custom security policy"
+)
+```
+
+### Modify a Policy
+
+```python
+# Update policy with new configuration
+new_config = GuardrailsConfig.bias()  # Switch to bias detection
+client.modify_policy(
+    policy_name="my-security-policy",
+    config=new_config,
+    description="Updated to detect bias"
+)
+```
+
+### Use a Policy
+
+```python
+# Apply policy to detect content
+response = client.policy_detect(
+    policy_name="my-security-policy",
+    text="Check this text for policy violations"
+)
+
+print(response)
+```
+
+### Get Policy Details
+
+```python
+# Retrieve policy configuration
+policy = client.get_policy("my-security-policy")
+print(policy)
+```
+
+### Delete a Policy
+
+```python
+# Remove a policy
+client.delete_policy("my-security-policy")
+```
+
+### Available Policy Options
+
+Policies can include any combination of these detectors:
+
+- `injection_attack`: Detect prompt injection attempts
+- `bias`: Detect biased content
+- `policy_violation`: Check against custom policy rules
+- `topic_detection`: Detect specific topics
+- `nsfw`: Filter inappropriate content
+- `toxicity`: Detect toxic language
+- `pii`: Detect personal information
+- `copyright_ip`: Check for copyright/IP violations
+- `system_prompt`: Detect system prompt leaks
+- `keyword_detector`: Check for specific keywords
+
+Each detector can be enabled/disabled and configured with specific options through `GuardrailsConfig`.
 
 ## Guardrails Client
 

enkryptai_sdk-0.1.3.dist-info/RECORD

@@ -0,0 +1,9 @@
+enkryptai_sdk/__init__.py,sha256=git4pQzKT36zA-wIDz71crkRhp91FFIYrJXehUcnofg,141
+enkryptai_sdk/guardrails.py,sha256=diBPOa07tUxxw4C-DwhWQWwWrHGoH_KoazsXI929OAc,6201
+enkryptai_sdk/guardrails_config.py,sha256=V1QYo6aCk0l9FUE4LEfJhmgM1rZB7NWdvkmP-6FN-X8,7462
+enkryptai_sdk/red_team.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enkryptai_sdk-0.1.3.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enkryptai_sdk-0.1.3.dist-info/METADATA,sha256=RuMr4SOP6iO3J8aCR2Y_Rbq68abZZ4Mymg74z3zy0-4,4578
+enkryptai_sdk-0.1.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+enkryptai_sdk-0.1.3.dist-info/top_level.txt,sha256=s2X9UJJwvJamNmr6ZXWyyQe60sXtQGWFuaBYfhgHI_4,14
+enkryptai_sdk-0.1.3.dist-info/RECORD,,

enkryptai_sdk-0.1.1.dist-info/RECORD

@@ -1,9 +0,0 @@
-enkryptai_sdk/__init__.py,sha256=git4pQzKT36zA-wIDz71crkRhp91FFIYrJXehUcnofg,141
-enkryptai_sdk/guardrails.py,sha256=rxUiHPAvdgIjX00XtAY5jPGde-_OEnpmV51jDxAZOSA,4596
-enkryptai_sdk/guardrails_config.py,sha256=oFhCX2hJGVFQfGcaJqji4enc35gK5dTc95uSWungRPE,2487
-enkryptai_sdk/red_team.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enkryptai_sdk-0.1.1.dist-info/LICENSE,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-enkryptai_sdk-0.1.1.dist-info/METADATA,sha256=DZDuoUjlb5ptOuGdMzTLzkZ561kYqis2VjjhajT3bnE,2324
-enkryptai_sdk-0.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-enkryptai_sdk-0.1.1.dist-info/top_level.txt,sha256=s2X9UJJwvJamNmr6ZXWyyQe60sXtQGWFuaBYfhgHI_4,14
-enkryptai_sdk-0.1.1.dist-info/RECORD,,