auratest 0.1.2__tar.gz

auratest-0.1.2/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: auratest
+Version: 0.1.2
+Summary: Test-Driven Development (TDD) framework for AI and Probabilistic Models.
+Author-email: "Rafly A.R" <ginganomercy@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+<div align="center">
+  <h1>AuraTest 🧪</h1>
+  <p><strong>Test-Driven Development (TDD) framework for AI and Probabilistic Models.</strong></p>
+  
+  [![PyPI version](https://badge.fury.io/py/auratest.svg)](https://badge.fury.io/py/auratest)
+  ![Python](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
+  ![License](https://img.shields.io/badge/License-MIT-green)
+</div>
+
+---
+
+## The Problem: Fragile AI Deployments
+Data Scientists rarely write Unit Tests because AI models are probabilistic. You cannot easily `assert output == 5`. Because of this, biased, illogical, and fragile models often leak into production undetected.
+
+## The Solution: AuraTest
+**AuraTest** allows you to test the *mathematical invariants* of your model rather than point outputs. It ensures your AI obeys the laws of physics, logic, and fairness before it is ever deployed.
+
+---
+
+## Installation
+
+Install AuraTest easily via pip:
+
+```bash
+pip install auratest
+```
+*(Requires `numpy` to be installed in your environment).*
+
+---
+
+## Quick Start (pytest)
+
+```python
+import numpy as np
+from auratest import assert_monotonic, assert_invariance
+
+def test_credit_model_is_logical():
+    # 1. Your trained model's predict function
+    def predict_risk(X):
+        return my_model.predict(X)
+        
+    sample_data = np.random.rand(10, 5) # 10 patients, 5 features
+    
+    # 2. Ensure that as Feature 2 (Age) increases, Risk strictly increases.
+    assert_monotonic(predict_risk, sample_data, feature_index=2, direction="increasing")
+    
+def test_credit_model_is_fair():
+    # 3. Ensure that altering Feature 0 (Gender) does NOT change predictions by > 1%
+    assert_invariance(predict_risk, sample_data, feature_index=0, tolerance=0.01)
+```
+
+## How It Works (Production Features)
+AuraTest acts as an independent testing engine wrapping your model's outputs. 
+
+*   **Anti-OOM Generator Engine:** Instead of hoarding memory, the perturbation engine uses batch generators. You can test gigabytes of synthetic data without crashing your CI/CD runners.
+*   **Safe Model Adapters:** Automatically intercepts and coerces arbitrary model outputs (whether it is a Pandas DataFrame, a PyTorch Tensor, or a Scikit-Learn Multiclass Probability array) into pure NumPy formats to ensure zero crashes during shape operations.
+*   **Strict & Customizable Math Bounds:** Exposes deep parameters (`steps`, `step_size`, `noise_std`) and features a `strict` monotonicity mode to cater to rigorous compliance and audit requirements.
+
+## Support This Project
+
+AuraTest is an open-source project built out of passion. If it has saved you from deploying a biased or broken model into production, consider supporting the creator by following on Instagram!
+
+[![Follow on Instagram](https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white)](https://instagram.com/galaxy_scream)
+
+---
+
+## Contributing & Testing
+
+We welcome PRs! To run the test suite locally and verify your changes:
+```bash
+# Clone the repository
+git clone https://github.com/ginganomercy/auratest.git
+cd auratest
+
+# Install with development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest tests/ -v
+```

auratest-0.1.2/README.md

@@ -0,0 +1,80 @@
+<div align="center">
+  <h1>AuraTest 🧪</h1>
+  <p><strong>Test-Driven Development (TDD) framework for AI and Probabilistic Models.</strong></p>
+  
+  [![PyPI version](https://badge.fury.io/py/auratest.svg)](https://badge.fury.io/py/auratest)
+  ![Python](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
+  ![License](https://img.shields.io/badge/License-MIT-green)
+</div>
+
+---
+
+## The Problem: Fragile AI Deployments
+Data Scientists rarely write Unit Tests because AI models are probabilistic. You cannot easily `assert output == 5`. Because of this, biased, illogical, and fragile models often leak into production undetected.
+
+## The Solution: AuraTest
+**AuraTest** allows you to test the *mathematical invariants* of your model rather than point outputs. It ensures your AI obeys the laws of physics, logic, and fairness before it is ever deployed.
+
+---
+
+## Installation
+
+Install AuraTest easily via pip:
+
+```bash
+pip install auratest
+```
+*(Requires `numpy` to be installed in your environment).*
+
+---
+
+## Quick Start (pytest)
+
+```python
+import numpy as np
+from auratest import assert_monotonic, assert_invariance
+
+def test_credit_model_is_logical():
+    # 1. Your trained model's predict function
+    def predict_risk(X):
+        return my_model.predict(X)
+        
+    sample_data = np.random.rand(10, 5) # 10 patients, 5 features
+    
+    # 2. Ensure that as Feature 2 (Age) increases, Risk strictly increases.
+    assert_monotonic(predict_risk, sample_data, feature_index=2, direction="increasing")
+    
+def test_credit_model_is_fair():
+    # 3. Ensure that altering Feature 0 (Gender) does NOT change predictions by > 1%
+    assert_invariance(predict_risk, sample_data, feature_index=0, tolerance=0.01)
+```
+
+## How It Works (Production Features)
+AuraTest acts as an independent testing engine wrapping your model's outputs. 
+
+*   **Anti-OOM Generator Engine:** Instead of hoarding memory, the perturbation engine uses batch generators. You can test gigabytes of synthetic data without crashing your CI/CD runners.
+*   **Safe Model Adapters:** Automatically intercepts and coerces arbitrary model outputs (whether it is a Pandas DataFrame, a PyTorch Tensor, or a Scikit-Learn Multiclass Probability array) into pure NumPy formats to ensure zero crashes during shape operations.
+*   **Strict & Customizable Math Bounds:** Exposes deep parameters (`steps`, `step_size`, `noise_std`) and features a `strict` monotonicity mode to cater to rigorous compliance and audit requirements.
+
+## Support This Project
+
+AuraTest is an open-source project built out of passion. If it has saved you from deploying a biased or broken model into production, consider supporting the creator by following on Instagram!
+
+[![Follow on Instagram](https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white)](https://instagram.com/galaxy_scream)
+
+---
+
+## Contributing & Testing
+
+We welcome PRs! To run the test suite locally and verify your changes:
+```bash
+# Clone the repository
+git clone https://github.com/ginganomercy/auratest.git
+cd auratest
+
+# Install with development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest tests/ -v
+```

auratest-0.1.2/auratest/__init__.py

@@ -0,0 +1,12 @@
+from .assertions import assert_monotonic, assert_invariance, assert_robustness
+from .exceptions import AuraTestError, MonotonicityError, InvarianceError, RobustnessError
+
+__all__ = [
+    "assert_monotonic",
+    "assert_invariance",
+    "assert_robustness",
+    "AuraTestError",
+    "MonotonicityError",
+    "InvarianceError",
+    "RobustnessError"
+]

auratest-0.1.2/auratest/assertions.py

@@ -0,0 +1,107 @@
+import numpy as np
+from typing import Callable, Any
+
+from .engine import generate_incremental_perturbations, perturb_feature_random, add_global_noise
+from .exceptions import MonotonicityError, InvarianceError, RobustnessError
+
+def _safe_predict(predict_fn: Callable, data: np.ndarray) -> np.ndarray:
+    """
+    Safely calls the predict function and ensures the output is a NumPy array.
+    This prevents crashes when models return PyTorch Tensors or Pandas Series.
+    """
+    preds = predict_fn(data)
+    return np.asarray(preds)
+
+def assert_monotonic(
+    predict_fn: Callable[[np.ndarray], Any], 
+    data: np.ndarray, 
+    feature_index: int, 
+    direction: str = "increasing",
+    steps: int = 5,
+    step_size: float = 1.0,
+    strict: bool = False
+) -> None:
+    """
+    Asserts that the model's output strictly follows a monotonic direction.
+    """
+    if direction not in ["increasing", "decreasing"]:
+        raise ValueError("direction must be either 'increasing' or 'decreasing'")
+        
+    generator = generate_incremental_perturbations(
+        data, feature_index, steps=steps, step_size=step_size
+    )
+    
+    prev_predictions = None
+    
+    for step, perturbed_data in enumerate(generator):
+        current_predictions = _safe_predict(predict_fn, perturbed_data)
+        
+        if prev_predictions is not None:
+            diff = current_predictions - prev_predictions
+            
+            if direction == "increasing":
+                # If strict, diff must be > 0. Else, diff must be >= 0.
+                if strict:
+                    violations = np.where(diff <= 0)[0]
+                else:
+                    violations = np.where(diff < 0)[0]
+                    
+                if len(violations) > 0:
+                    raise MonotonicityError(f"Monotonicity violated! Expected output to strictly increase, but it failed for sample index {violations[0]}.")
+            else:
+                if strict:
+                    violations = np.where(diff >= 0)[0]
+                else:
+                    violations = np.where(diff > 0)[0]
+                    
+                if len(violations) > 0:
+                    raise MonotonicityError(f"Monotonicity violated! Expected output to strictly decrease, but it failed for sample index {violations[0]}.")
+                    
+        prev_predictions = current_predictions
+
+def assert_invariance(
+    predict_fn: Callable[[np.ndarray], Any], 
+    data: np.ndarray, 
+    feature_index: int, 
+    tolerance: float = 1e-5,
+    noise_std: float = 1.0
+) -> None:
+    """
+    Asserts that altering a specific feature does NOT change the prediction beyond tolerance.
+    """
+    original_predictions = _safe_predict(predict_fn, data)
+    
+    perturbed_data = perturb_feature_random(data, feature_index, noise_std=noise_std)
+    perturbed_predictions = _safe_predict(predict_fn, perturbed_data)
+    
+    diff = np.abs(original_predictions - perturbed_predictions)
+    violations = np.where(diff > tolerance)[0]
+    
+    if len(violations) > 0:
+        max_diff = np.max(diff[violations])
+        raise InvarianceError(
+            f"Invariance violated! Changing feature {feature_index} caused the output to change by {max_diff:.6f}, exceeding tolerance {tolerance}."
+        )
+
+def assert_robustness(
+    predict_fn: Callable[[np.ndarray], Any], 
+    data: np.ndarray, 
+    noise_std: float = 0.01, 
+    tolerance: float = 0.1
+) -> None:
+    """
+    Asserts that adding small Gaussian noise doesn't drastically swing the output.
+    """
+    original_predictions = _safe_predict(predict_fn, data)
+    
+    noisy_data = add_global_noise(data, noise_std=noise_std)
+    noisy_predictions = _safe_predict(predict_fn, noisy_data)
+    
+    diff = np.abs(original_predictions - noisy_predictions)
+    violations = np.where(diff > tolerance)[0]
+    
+    if len(violations) > 0:
+        max_diff = np.max(diff[violations])
+        raise RobustnessError(
+            f"Robustness violated! Small input noise ({noise_std}) caused output deviation of {max_diff:.6f}, exceeding tolerance {tolerance}."
+        )

auratest-0.1.2/auratest/engine.py

@@ -0,0 +1,51 @@
+import numpy as np
+from typing import Iterator
+
+def generate_incremental_perturbations(
+    data: np.ndarray, 
+    feature_index: int, 
+    steps: int = 5, 
+    step_size: float = 1.0
+) -> Iterator[np.ndarray]:
+    """
+    Yields perturbed copies of the data incrementally.
+    Uses a generator to prevent Out-Of-Memory (OOM) errors on massive datasets.
+    """
+    if not isinstance(data, np.ndarray):
+        raise TypeError("AuraTest requires input data to be a NumPy array.")
+        
+    for step in range(steps):
+        # Create a deep copy to avoid memory leakage/mutation
+        modified_data = data.copy()
+        # Increment the specific feature
+        modified_data[:, feature_index] += (step * step_size)
+        yield modified_data
+
+def perturb_feature_random(
+    data: np.ndarray, 
+    feature_index: int, 
+    noise_std: float = 1.0
+) -> np.ndarray:
+    """
+    Generates a copy of the data where the target feature is randomized.
+    """
+    if not isinstance(data, np.ndarray):
+        raise TypeError("AuraTest requires input data to be a NumPy array.")
+        
+    modified_data = data.copy()
+    noise = np.random.normal(0, noise_std, size=modified_data.shape[0])
+    modified_data[:, feature_index] += noise
+    return modified_data
+
+def add_global_noise(
+    data: np.ndarray, 
+    noise_std: float = 0.01
+) -> np.ndarray:
+    """
+    Adds Gaussian noise to all features.
+    """
+    if not isinstance(data, np.ndarray):
+        raise TypeError("AuraTest requires input data to be a NumPy array.")
+        
+    noise = np.random.normal(0, noise_std, size=data.shape)
+    return data + noise

auratest-0.1.2/auratest/exceptions.py

@@ -0,0 +1,18 @@
+class AuraTestError(AssertionError):
+    """
+    Base exception for AuraTest failures. 
+    Inherits from AssertionError so it automatically fails test runners like Pytest.
+    """
+    pass
+
+class MonotonicityError(AuraTestError):
+    """Raised when a model violates monotonic constraints."""
+    pass
+
+class InvarianceError(AuraTestError):
+    """Raised when a model output changes unexpectedly (violates fairness/invariance)."""
+    pass
+
+class RobustnessError(AuraTestError):
+    """Raised when a model is overly sensitive to noise."""
+    pass

auratest-0.1.2/auratest.egg-info/PKG-INFO

@@ -0,0 +1,95 @@
+Metadata-Version: 2.4
+Name: auratest
+Version: 0.1.2
+Summary: Test-Driven Development (TDD) framework for AI and Probabilistic Models.
+Author-email: "Rafly A.R" <ginganomercy@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.20.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+
+<div align="center">
+  <h1>AuraTest 🧪</h1>
+  <p><strong>Test-Driven Development (TDD) framework for AI and Probabilistic Models.</strong></p>
+  
+  [![PyPI version](https://badge.fury.io/py/auratest.svg)](https://badge.fury.io/py/auratest)
+  ![Python](https://img.shields.io/badge/Python-3.9%20%7C%203.10%20%7C%203.11%20%7C%203.12-blue)
+  ![License](https://img.shields.io/badge/License-MIT-green)
+</div>
+
+---
+
+## The Problem: Fragile AI Deployments
+Data Scientists rarely write Unit Tests because AI models are probabilistic. You cannot easily `assert output == 5`. Because of this, biased, illogical, and fragile models often leak into production undetected.
+
+## The Solution: AuraTest
+**AuraTest** allows you to test the *mathematical invariants* of your model rather than point outputs. It ensures your AI obeys the laws of physics, logic, and fairness before it is ever deployed.
+
+---
+
+## Installation
+
+Install AuraTest easily via pip:
+
+```bash
+pip install auratest
+```
+*(Requires `numpy` to be installed in your environment).*
+
+---
+
+## Quick Start (pytest)
+
+```python
+import numpy as np
+from auratest import assert_monotonic, assert_invariance
+
+def test_credit_model_is_logical():
+    # 1. Your trained model's predict function
+    def predict_risk(X):
+        return my_model.predict(X)
+        
+    sample_data = np.random.rand(10, 5) # 10 patients, 5 features
+    
+    # 2. Ensure that as Feature 2 (Age) increases, Risk strictly increases.
+    assert_monotonic(predict_risk, sample_data, feature_index=2, direction="increasing")
+    
+def test_credit_model_is_fair():
+    # 3. Ensure that altering Feature 0 (Gender) does NOT change predictions by > 1%
+    assert_invariance(predict_risk, sample_data, feature_index=0, tolerance=0.01)
+```
+
+## How It Works (Production Features)
+AuraTest acts as an independent testing engine wrapping your model's outputs. 
+
+*   **Anti-OOM Generator Engine:** Instead of hoarding memory, the perturbation engine uses batch generators. You can test gigabytes of synthetic data without crashing your CI/CD runners.
+*   **Safe Model Adapters:** Automatically intercepts and coerces arbitrary model outputs (whether it is a Pandas DataFrame, a PyTorch Tensor, or a Scikit-Learn Multiclass Probability array) into pure NumPy formats to ensure zero crashes during shape operations.
+*   **Strict & Customizable Math Bounds:** Exposes deep parameters (`steps`, `step_size`, `noise_std`) and features a `strict` monotonicity mode to cater to rigorous compliance and audit requirements.
+
+## Support This Project
+
+AuraTest is an open-source project built out of passion. If it has saved you from deploying a biased or broken model into production, consider supporting the creator by following on Instagram!
+
+[![Follow on Instagram](https://img.shields.io/badge/Instagram-E4405F?style=for-the-badge&logo=instagram&logoColor=white)](https://instagram.com/galaxy_scream)
+
+---
+
+## Contributing & Testing
+
+We welcome PRs! To run the test suite locally and verify your changes:
+```bash
+# Clone the repository
+git clone https://github.com/ginganomercy/auratest.git
+cd auratest
+
+# Install with development dependencies
+pip install -e .[dev]
+
+# Run tests
+pytest tests/ -v
+```

auratest-0.1.2/auratest.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+auratest/__init__.py
+auratest/assertions.py
+auratest/engine.py
+auratest/exceptions.py
+auratest.egg-info/PKG-INFO
+auratest.egg-info/SOURCES.txt
+auratest.egg-info/dependency_links.txt
+auratest.egg-info/requires.txt
+auratest.egg-info/top_level.txt
+tests/test_assertions.py

auratest-0.1.2/auratest.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

auratest-0.1.2/auratest.egg-info/requires.txt

@@ -0,0 +1,4 @@
+numpy>=1.20.0
+
+[dev]
+pytest

auratest-0.1.2/auratest.egg-info/top_level.txt

@@ -0,0 +1 @@
+auratest

auratest-0.1.2/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "auratest"
+version = "0.1.2"
+authors = [
+  { name="Rafly A.R", email="ginganomercy@example.com" },
+]
+description = "Test-Driven Development (TDD) framework for AI and Probabilistic Models."
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.20.0"
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+]

auratest-0.1.2/setup.cfg

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

auratest-0.1.2/tests/test_assertions.py

@@ -0,0 +1,68 @@
+import pytest
+import numpy as np
+from auratest import assert_monotonic, assert_invariance, assert_robustness
+from auratest.exceptions import MonotonicityError, InvarianceError, RobustnessError
+
+# --- DUMMY MODELS ---
+
+def good_credit_model(X: np.ndarray) -> np.ndarray:
+    """
+    A logical model. 
+    Feature 0: Income (Positive weight)
+    Feature 1: Age (Positive weight)
+    Feature 2: Gender (Zero weight - Fair model)
+    """
+    weights = np.array([2.0, 1.5, 0.0])
+    return np.dot(X, weights)
+
+def bad_credit_model(X: np.ndarray) -> np.ndarray:
+    """
+    A flawed model.
+    Feature 0: Income (Negative weight! Violates monotonicity)
+    Feature 1: Age (Positive weight)
+    Feature 2: Gender (High weight! Violates invariance/fairness)
+    """
+    weights = np.array([-1.5, 1.5, 5.0])
+    return np.dot(X, weights)
+
+def fragile_model(X: np.ndarray) -> np.ndarray:
+    """
+    A fragile model that swings wildly with small noise.
+    """
+    # Exaggerates any noise by 1000x
+    return np.sum(X * 1000, axis=1)
+
+# --- TESTS ---
+
+def test_monotonicity_passes_on_good_model():
+    data = np.random.rand(10, 3)
+    # Income (Feature 0) should strictly increase output
+    assert_monotonic(good_credit_model, data, feature_index=0, direction="increasing")
+
+def test_monotonicity_fails_on_bad_model():
+    data = np.random.rand(10, 3)
+    # Income (Feature 0) has a negative weight in bad_model, so increasing it will decrease output!
+    with pytest.raises(MonotonicityError):
+        assert_monotonic(bad_credit_model, data, feature_index=0, direction="increasing")
+
+def test_invariance_passes_on_fair_model():
+    data = np.random.rand(10, 3)
+    # Gender (Feature 2) has zero weight, so changing it should not affect output
+    assert_invariance(good_credit_model, data, feature_index=2, tolerance=0.01)
+
+def test_invariance_fails_on_biased_model():
+    data = np.random.rand(10, 3)
+    # Gender (Feature 2) has a high weight, so randomizing it will drastically change the output
+    with pytest.raises(InvarianceError):
+        assert_invariance(bad_credit_model, data, feature_index=2, tolerance=0.01)
+
+def test_robustness_passes_on_good_model():
+    data = np.random.rand(10, 3)
+    # Good model is linear with small weights, so small noise = small change
+    assert_robustness(good_credit_model, data, noise_std=0.01, tolerance=0.5)
+
+def test_robustness_fails_on_fragile_model():
+    data = np.random.rand(10, 3)
+    # Fragile model amplifies noise by 1000x, it will easily exceed tolerance
+    with pytest.raises(RobustnessError):
+        assert_robustness(fragile_model, data, noise_std=0.01, tolerance=0.5)