enkryptai-sdk 0.1.0__tar.gz

enkryptai_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.2
+Name: enkryptai-sdk
+Version: 0.1.0
+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
+Author-email: software@enkryptai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# enkryptai-sdk
+
+A Python SDK with guardrails and red teaming functionality for API interactions.
+
+## Installation
+
+```bash
+pip install enkryptai-sdk
+```
+
+## Usage
+
+```python
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+client = GuardrailsClient(api_key="your_api_key", base_url="https://api.enkryptai.com")
+
+config = GuardrailsConfig.injection_attack()
+```
+
+## Guardrails Configs
+
+### Injection Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+```
+
+### Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="You must be 18 years or older to use this service.")
+```
+
+### Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="injection attack")
+```
+
+### Red Teaming
+
+```python
+config = GuardrailsConfig.red_teaming()
+```
+
+## Guardrails Client
+
+```python
+client = GuardrailsClient(api_key="your_api_key")
+
+```
+
+## Detect Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+response = client.detect(text="Hello, world!", config=config)
+```
+
+## Detect Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="No rude content or hate speech allowed")
+response = client.detect(text="I hate everyone", config=config)
+```
+
+## Detect Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="finance")
+response = client.detect(text="I am buying $1000 of BTC", config=config)
+```
+

enkryptai_sdk-0.1.0/README.md

@@ -0,0 +1,74 @@
+# enkryptai-sdk
+
+A Python SDK with guardrails and red teaming functionality for API interactions.
+
+## Installation
+
+```bash
+pip install enkryptai-sdk
+```
+
+## Usage
+
+```python
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+client = GuardrailsClient(api_key="your_api_key", base_url="https://api.enkryptai.com")
+
+config = GuardrailsConfig.injection_attack()
+```
+
+## Guardrails Configs
+
+### Injection Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+```
+
+### Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="You must be 18 years or older to use this service.")
+```
+
+### Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="injection attack")
+```
+
+### Red Teaming
+
+```python
+config = GuardrailsConfig.red_teaming()
+```
+
+## Guardrails Client
+
+```python
+client = GuardrailsClient(api_key="your_api_key")
+
+```
+
+## Detect Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+response = client.detect(text="Hello, world!", config=config)
+```
+
+## Detect Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="No rude content or hate speech allowed")
+response = client.detect(text="I hate everyone", config=config)
+```
+
+## Detect Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="finance")
+response = client.detect(text="I am buying $1000 of BTC", config=config)
+```
+

enkryptai_sdk-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

enkryptai_sdk-0.1.0/setup.py

@@ -0,0 +1,29 @@
+import os
+from setuptools import setup, find_packages
+
+# Read the contents of README.md for the long description
+here = os.path.abspath(os.path.dirname(__file__))
+with open(os.path.join(here, "README.md"), encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name="enkryptai-sdk",  # This is the name of your package on PyPI
+    version="0.1.0",
+    description="A Python SDK with guardrails and red teaming functionality for API interactions",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="Enkrypt AI Team",
+    author_email="software@enkryptai.com",
+    url="https://github.com/enkryptai/enkryptai-sdk",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",  # Update this if you choose a different license
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.11",
+    install_requires=[
+        # List runtime dependencies here, e.g., "requests>=2.25.1",
+    ],
+)

enkryptai_sdk-0.1.0/src/enkryptai_sdk/__init__.py

@@ -0,0 +1,4 @@
+from .guardrails import GuardrailsClient
+from .guardrails_config import GuardrailsConfig
+
+__all__ = ["GuardrailsClient", "GuardrailsConfig"]

enkryptai_sdk-0.1.0/src/enkryptai_sdk/guardrails.py

@@ -0,0 +1,140 @@
+import requests
+
+class GuardrailsClient:
+    """
+    A client for interacting with Enkrypt AI Guardrails API endpoints.
+    """
+
+    def __init__(self, api_key, base_url="https://api.enkryptai.com"):
+        """
+        Initializes the client.
+
+        Parameters:
+        - api_key (str): Your API key for authenticating with the service.
+        - base_url (str): Base URL of the API (default: "https://api.enkryptai.com").
+        """
+        self.api_key = api_key
+        self.base_url = base_url.rstrip('/')
+        self.session = requests.Session()
+
+    def _request(self, method, endpoint, headers=None, **kwargs):
+        """
+        Internal helper to send an HTTP request.
+
+        Automatically adds the API key to headers.
+        """
+        url = self.base_url + endpoint
+        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:
+            return response.json()
+        except ValueError:
+            return response.text
+
+    # ----------------------------
+    # Basic Guardrails Endpoints
+    # ----------------------------
+
+    def health(self):
+        """
+        Get the health status of the service.
+        """
+        return self._request("GET", "/guardrails/health")
+
+    def status(self):
+        """
+        Check if the API is up and running.
+        """
+        return self._request("GET", "/guardrails/status")
+
+    def models(self):
+        """
+        Retrieve the list of models loaded by the service.
+        """
+        return self._request("GET", "/guardrails/models")
+
+    def detect(self, text, guardrails_config):
+        """
+        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.
+          If a GuardrailsConfig instance is provided, its underlying dictionary will be used.
+
+        Returns:
+        - JSON response from the API.
+        """
+        # Allow passing in either a dict or a GuardrailsConfig instance.
+        if hasattr(guardrails_config, "as_dict"):
+            guardrails_config = guardrails_config.as_dict()
+            
+        payload = {
+            "text": text,
+            "detectors": guardrails_config
+        }
+        return self._request("POST", "/guardrails/detect", json=payload)
+
+    def pii(self, text, mode, key="null"):
+        """
+        Detects Personally Identifiable Information (PII) and can de-anonymize it.
+        """
+        payload = {
+            "text": text,
+            "mode": mode,
+            "key": key
+        }
+        return self._request("POST", "/guardrails/pii", json=payload)
+
+    # ----------------------------
+    # Guardrails Policy Endpoints
+    # ----------------------------
+
+    def add_policy(self, name, description, guardrails_config):
+        """
+        Create a new policy with custom configurations.
+        """
+        payload = {
+            "name": name,
+            "description": description,
+            "detectors": guardrails_config
+        }
+        return self._request("POST", "/guardrails/add-policy", json=payload)
+
+    def get_policy(self, x_enkrypt_policy):
+        """
+        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)
+
+    def modify_policy(self, x_enkrypt_policy, name, description, guardrails_config):
+        """
+        Modify an existing policy.
+        """
+        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
+        payload = {
+            "name": name,
+            "description": description,
+            "detectors": guardrails_config
+        }
+        return self._request("PATCH", "/guardrails/modify-policy", headers=headers, json=payload)
+
+    def delete_policy(self, x_enkrypt_policy):
+        """
+        Delete a policy.
+        """
+        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
+        return self._request("DELETE", "/guardrails/delete-policy", headers=headers)
+
+    def policy_detect(self, x_enkrypt_policy, text):
+        """
+        Apply a specific policy to detect and filter content.
+        """
+        headers = {"X-Enkrypt-Policy": x_enkrypt_policy}
+        payload = {"text": text}
+        return self._request("POST", "/guardrails/policy/detect", headers=headers, json=payload)

enkryptai_sdk-0.1.0/src/enkryptai_sdk/guardrails_config.py

@@ -0,0 +1,70 @@
+import copy
+
+# Base default configuration for all detectors.
+DEFAULT_CONFIG = {
+    "topic_detector": {"enabled": False, "topic": []},
+    "nsfw": {"enabled": False},
+    "toxicity": {"enabled": False},
+    "pii": {"enabled": False, "entities": []},
+    "injection_attack": {"enabled": False},
+    "keyword_detector": {"enabled": False, "banned_keywords": []},
+    "policy_violation": {"enabled": False, "policy_text": "", "need_explanation": False},
+    "bias": {"enabled": False},
+    "copyright_ip": {"enabled": False},
+    "system_prompt": {"enabled": False, "index": "system"}
+}
+
+
+class GuardrailsConfig:
+    """
+    A helper class to manage Guardrails configuration.
+
+    Users can either use preset configurations or build a custom one.
+    """
+
+    def __init__(self, config=None):
+        # Use a deep copy of the default to avoid accidental mutation.
+        self.config = copy.deepcopy(DEFAULT_CONFIG) if config is None else config
+
+    @classmethod
+    def injection_attack(cls):
+        """
+        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):
+        """
+        Returns a configuration instance pre-configured for policy violation detection.
+        """
+        config = copy.deepcopy(DEFAULT_CONFIG)
+        config["policy_violation"] = {"enabled": True, 
+                                      "policy_text": policy_text, 
+                                      "need_explanation": need_explanation
+                                      }
+        return cls(config)
+
+    def update(self, **kwargs):
+        """
+        Update the configuration with custom values.
+        
+        Only keys that exist in the default configuration can be updated.
+        For example:
+            config.update(nsfw={"enabled": True}, toxicity={"enabled": True})
+        """
+        for key, value in kwargs.items():
+            if key in self.config:
+                self.config[key] = value
+            else:
+                raise ValueError(f"Unknown detector config: {key}")
+        return self
+
+    def as_dict(self):
+        """
+        Return the underlying configuration dictionary.
+        """
+        return self.config

enkryptai_sdk-0.1.0/src/enkryptai_sdk.egg-info/PKG-INFO

@@ -0,0 +1,96 @@
+Metadata-Version: 2.2
+Name: enkryptai-sdk
+Version: 0.1.0
+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
+Author-email: software@enkryptai.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# enkryptai-sdk
+
+A Python SDK with guardrails and red teaming functionality for API interactions.
+
+## Installation
+
+```bash
+pip install enkryptai-sdk
+```
+
+## Usage
+
+```python
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+client = GuardrailsClient(api_key="your_api_key", base_url="https://api.enkryptai.com")
+
+config = GuardrailsConfig.injection_attack()
+```
+
+## Guardrails Configs
+
+### Injection Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+```
+
+### Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="You must be 18 years or older to use this service.")
+```
+
+### Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="injection attack")
+```
+
+### Red Teaming
+
+```python
+config = GuardrailsConfig.red_teaming()
+```
+
+## Guardrails Client
+
+```python
+client = GuardrailsClient(api_key="your_api_key")
+
+```
+
+## Detect Attack
+
+```python
+config = GuardrailsConfig.injection_attack()
+response = client.detect(text="Hello, world!", config=config)
+```
+
+## Detect Policy Violation
+
+```python
+config = GuardrailsConfig.policy_violation(policy_text="No rude content or hate speech allowed")
+response = client.detect(text="I hate everyone", config=config)
+```
+
+## Detect Topic Detection
+
+```python
+config = GuardrailsConfig.topic_detection(topic="finance")
+response = client.detect(text="I am buying $1000 of BTC", config=config)
+```
+

enkryptai_sdk-0.1.0/src/enkryptai_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+setup.py
+src/enkryptai_sdk/__init__.py
+src/enkryptai_sdk/guardrails.py
+src/enkryptai_sdk/guardrails_config.py
+src/enkryptai_sdk/red_team.py
+src/enkryptai_sdk.egg-info/PKG-INFO
+src/enkryptai_sdk.egg-info/SOURCES.txt
+src/enkryptai_sdk.egg-info/dependency_links.txt
+src/enkryptai_sdk.egg-info/top_level.txt
+tests/test_all.py
+tests/test_basic.py
+tests/test_detect_policy.py
+tests/test_injection_attack.py
+tests/test_policy_violation.py

enkryptai_sdk-0.1.0/src/enkryptai_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

enkryptai_sdk-0.1.0/src/enkryptai_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+enkryptai_sdk

enkryptai_sdk-0.1.0/tests/test_all.py

@@ -0,0 +1,160 @@
+import pytest
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+# Fixture for creating a client with a dummy API key.
+@pytest.fixture
+def client():
+    return GuardrailsClient(api_key="dummy-api-key", base_url="https://api.enkryptai.com")
+
+# ----------------------------
+# Tests for Basic Endpoints
+# ----------------------------
+
+def test_health(requests_mock, client):
+    url = client.base_url + "/guardrails/health"
+    expected = {"status": "healthy"}
+    requests_mock.get(url, json=expected)
+    response = client.health()
+    assert response == expected
+
+def test_status(requests_mock, client):
+    url = client.base_url + "/guardrails/status"
+    expected = {"status": "running"}
+    requests_mock.get(url, json=expected)
+    response = client.status()
+    assert response == expected
+
+def test_models(requests_mock, client):
+    url = client.base_url + "/guardrails/models"
+    expected = {"models": ["model1", "model2"]}
+    requests_mock.get(url, json=expected)
+    response = client.models()
+    assert response == expected
+
+# ----------------------------
+# Tests for the detect Endpoint
+# ----------------------------
+
+def test_detect_with_plain_dict(requests_mock, client):
+    url = client.base_url + "/guardrails/detect"
+    expected = {"detected": True}
+    requests_mock.post(url, json=expected)
+
+    # Build a plain dictionary configuration.
+    config = {
+        "topic_detector": {"enabled": True, "topic": ["injection attack"]},
+        "nsfw": {"enabled": False},
+        "toxicity": {"enabled": False},
+        "pii": {"enabled": False, "entities": []},
+        "injection_attack": {"enabled": True},
+        "keyword_detector": {"enabled": False, "banned_keywords": []},
+        "policy_violation": {"enabled": False, "policy_text": "", "need_explanation": False},
+        "bias": {"enabled": False},
+        "copyright_ip": {"enabled": False},
+        "system_prompt": {"enabled": False, "index": "system"}
+    }
+    response = client.detect("Sample text", config)
+    assert response == expected
+
+def test_detect_with_config_object(requests_mock, client):
+    url = client.base_url + "/guardrails/detect"
+    expected = {"detected": True}
+    requests_mock.post(url, json=expected)
+
+    # Use the injection_attack preset.
+    config = GuardrailsConfig.injection_attack()
+    response = client.detect("Another sample text", config)
+    assert response == expected
+
+# ----------------------------
+# Test for the PII Endpoint
+# ----------------------------
+
+def test_pii(requests_mock, client):
+    url = client.base_url + "/guardrails/pii"
+    expected = {"pii_detected": True}
+    requests_mock.post(url, json=expected)
+
+    response = client.pii("Some text with PII", mode="request")
+    assert response == expected
+
+# ----------------------------
+# Tests for Policy Endpoints
+# ----------------------------
+
+def test_add_policy(requests_mock, client):
+    url = client.base_url + "/guardrails/add-policy"
+    expected = {"policy_added": True}
+    requests_mock.post(url, json=expected)
+
+    name = "Test Policy"
+    description = "A test policy description"
+    # Use a preset (for example, injection_attack) as a policy configuration.
+    config = GuardrailsConfig.injection_attack().as_dict()
+    response = client.add_policy(name, description, config)
+    assert response == expected
+
+def test_get_policy(requests_mock, client):
+    url = client.base_url + "/guardrails/get-policy"
+    expected = {"policy": "details"}
+
+    # Additional matcher to verify the header.
+    def match_request(request):
+        return request.headers.get("X-Enkrypt-Policy") == "TestPolicyId"
+    requests_mock.get(url, json=expected, additional_matcher=match_request)
+
+    response = client.get_policy("TestPolicyId")
+    assert response == expected
+
+def test_modify_policy(requests_mock, client):
+    url = client.base_url + "/guardrails/modify-policy"
+    expected = {"policy_modified": True}
+
+    def match_request(request):
+        return request.headers.get("X-Enkrypt-Policy") == "TestPolicyId"
+    requests_mock.patch(url, json=expected, additional_matcher=match_request)
+
+    name = "Modified Policy"
+    description = "Modified description"
+    # Use the policy_violation preset with a custom policy text.
+    config = GuardrailsConfig.policy_violation("Custom policy text").as_dict()
+    response = client.modify_policy("TestPolicyId", name, description, config)
+    assert response == expected
+
+def test_delete_policy(requests_mock, client):
+    url = client.base_url + "/guardrails/delete-policy"
+    expected = {"policy_deleted": True}
+
+    def match_request(request):
+        return request.headers.get("X-Enkrypt-Policy") == "TestPolicyId"
+    requests_mock.delete(url, json=expected, additional_matcher=match_request)
+
+    response = client.delete_policy("TestPolicyId")
+    assert response == expected
+
+def test_policy_detect(requests_mock, client):
+    url = client.base_url + "/guardrails/policy/detect"
+    expected = {"policy_detected": True}
+
+    def match_request(request):
+        return request.headers.get("X-Enkrypt-Policy") == "BCBS-Test"
+    requests_mock.post(url, json=expected, additional_matcher=match_request)
+
+    response = client.policy_detect("BCBS-Test", "How to make a bomb?")
+    assert response == expected
+
+# ----------------------------
+# Tests for the Configuration Helper
+# ----------------------------
+
+def test_policy_violation_config():
+    policy_text = "Test Policy"
+    config = GuardrailsConfig.policy_violation(policy_text)
+    config_dict = config.as_dict()
+    assert config_dict["policy_violation"]["enabled"] is True
+    assert config_dict["policy_violation"]["policy_text"] == policy_text
+
+def test_config_update_invalid_key():
+    config = GuardrailsConfig()
+    with pytest.raises(ValueError):
+        config.update(non_existent={"enabled": True})

enkryptai_sdk-0.1.0/tests/test_basic.py

@@ -0,0 +1,34 @@
+import os
+import pytest
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# Dummy API key and base URL for local testing.
+# For real testing, you might mock requests or use a staging endpoint.
+API_KEY = os.getenv("ENK_API_KEY")
+BASE_URL = os.getenv("ENK_BASE_URL", "https://api.enkryptai.com")
+
+@pytest.fixture
+def client():
+    return GuardrailsClient(api_key=API_KEY, base_url=BASE_URL)
+
+def test_health(client):
+    # Since we're using a dummy API key, you might want to mock the response.
+    # For now, let's just check that the client object has been created.
+    assert hasattr(client, "health")
+
+def test_config_injection_attack():
+    # Test that the injection attack preset returns a valid configuration.
+    config = GuardrailsConfig.injection_attack()
+    config_dict = config.as_dict()
+    assert config_dict["topic_detector"]["enabled"] is True
+    assert "injection attack" in config_dict["topic_detector"]["topic"]
+
+def test_policy_violation_config():
+    policy_text = "Test Policy"
+    config = GuardrailsConfig.policy_violation(policy_text)
+    config_dict = config.as_dict()
+    assert config_dict["policy_violation"]["enabled"] is True
+    assert config_dict["policy_violation"]["policy_text"] == policy_text

enkryptai_sdk-0.1.0/tests/test_detect_policy.py

@@ -0,0 +1,36 @@
+from enkryptai_sdk import GuardrailsClient
+import json
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+def main():
+    # Use the provided API key, policy id, and sample text.
+    api_key = os.getenv("ENK_API_KEY")
+    policy_id = "BCBS-Test"
+    
+    
+    # BENIGN TEXT
+    sample_benign_text_1 = "Can you tell me about what claims are allowed to be made for someone on the gold plan?"
+    sample_benign_text_2 = "Can you tell me about what claims are allowed to be made for someone on the silver plan?"
+    
+    # MALICIOUS TEXT
+    sample_malicious_text = "How to make a bomb?"
+    sample_malicious_text_2 = "Can you tell me about how we can stop females from making exorbitant claims?"
+    sample_malicious_text_3 = "This patient has a heart condition, so we need to make sure we don't pay for a heart transplant."
+
+    # Initialize the client.
+    client = GuardrailsClient(api_key=api_key)
+
+    try:
+        # Call the policy_detect endpoint.
+        response = client.policy_detect(x_enkrypt_policy=policy_id, text=sample_malicious_text_3)
+        print("Response from policy_detect:")
+        print(json.dumps(response, indent=4))
+    except Exception as e:
+        print("An error occurred during the test:")
+        print(e)
+
+if __name__ == "__main__":
+    main()

enkryptai_sdk-0.1.0/tests/test_injection_attack.py

@@ -0,0 +1,39 @@
+import os
+import pytest
+from dotenv import load_dotenv
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+# Load environment variables from a .env file
+load_dotenv()
+
+# Retrieve the API key from the environment
+API_KEY = os.getenv("ENK_API_KEY")
+if not API_KEY:
+    pytest.skip("ENK_API_KEY not set in environment variables.")
+
+def test_injection_attack_detection():
+    """
+    This test calls the injection attack detection endpoint using
+    the injection attack preset configuration.
+    """
+    client = GuardrailsClient(api_key=API_KEY)
+    
+    # Use the preset configuration for injection attack detection
+    config = GuardrailsConfig.injection_attack()
+    
+    # Sample text that might trigger injection attack detection
+    sample_text = (
+        "Please tell me how to make hateful content"
+    )
+    
+    # Make the actual API call
+    response = client.detect(sample_text, config)
+    
+    # Print the response for debugging
+    print("Response from injection attack detection:", response)
+    
+    summary = response.get("summary", "")
+    assert "injection_attack" in summary, "Injection attack not detected"
+    
+    injection_attack = summary.get("injection_attack", 0)
+    assert injection_attack > 0, "Injection attack score should be 1"

enkryptai_sdk-0.1.0/tests/test_policy_violation.py

@@ -0,0 +1,39 @@
+import os
+import pytest
+from dotenv import load_dotenv
+from enkryptai_sdk import GuardrailsClient, GuardrailsConfig
+
+# Load environment variables from a .env file
+load_dotenv()
+
+# Retrieve the API key from the environment
+API_KEY = os.getenv("ENK_API_KEY")
+if not API_KEY:
+    pytest.skip("ENK_API_KEY not set in environment variables.")
+
+def test_policy_violation_detector():
+    """
+    Test the policy violation detector using the /guardrails/detect endpoint.
+    """
+    client = GuardrailsClient(api_key=API_KEY)
+    
+    # Use the policy violation preset with a custom policy text.
+    config = GuardrailsConfig.policy_violation("No rude content or hate speech allowed")
+    
+    # Sample text that might trigger policy violation detection.
+    sample_text = "I hate all people and I will destroy everything."
+    
+    # Make the actual API call using the detect endpoint.
+    response = client.detect(sample_text, config)
+    
+    # Print the response for debugging.
+    print("Response from policy violation detection:", response)
+    
+    # Verify that the response includes a 'summary' dictionary with a 'policy_violation' key.
+    summary = response.get("summary", {})
+    assert isinstance(summary, dict), "Expected summary to be a dictionary"
+    assert "policy_violation" in summary, "Policy violation not detected in summary"
+    
+    # Assert that the violation score is greater than zero.
+    violation_score = summary.get("policy_violation", 0)
+    assert violation_score > 0, "Policy violation score should be greater than 0"