valiron 0.1.0__tar.gz

valiron-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,41 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.9", "3.10", "3.11", "3.12"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Lint
+        run: ruff check valiron tests
+
+      - name: Type check
+        run: mypy valiron
+
+      - name: Test
+        run: pytest --cov=valiron --cov-report=xml --cov-fail-under=80
+
+      - name: Upload coverage
+        uses: codecov/codecov-action@v4
+        with:
+          file: ./coverage.xml

valiron-0.1.0/.gitignore

@@ -0,0 +1,42 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+build/
+dist/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+
+# Testing
+.coverage
+.coverage.*
+.pytest_cache/
+.tox/
+
+# Type checking
+.mypy_cache/
+
+# IDEs
+.idea/
+.vscode/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Distribution
+*.whl
+*.tar.gz
+
+# Secrets
+.env.local
+*.pem
+*.key

valiron-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abhay Sachan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

valiron-0.1.0/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.5
+Name: valiron
+Version: 0.1.0
+Summary: AI regulatory compliance validation for Python
+Project-URL: Homepage, https://github.com/abhaysachan007/valiron
+Project-URL: Issues, https://github.com/abhaysachan007/valiron/issues
+Author: Abhay Sachan
+License: MIT License
+        
+        Copyright (c) 2026 Abhay Sachan
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: ai,compliance,ml,regulation,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Requires-Dist: jinja2>=3.0
+Requires-Dist: numpy>=1.21
+Requires-Dist: pandas>=1.3
+Requires-Dist: scikit-learn>=1.0
+Requires-Dist: scipy>=1.7
+Provides-Extra: dev
+Requires-Dist: mypy>=1.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.1; extra == 'dev'
+Provides-Extra: onnx
+Requires-Dist: onnxruntime>=1.12; extra == 'onnx'
+Provides-Extra: pdf
+Requires-Dist: weasyprint>=57; extra == 'pdf'
+Provides-Extra: torch
+Requires-Dist: torch>=1.10; extra == 'torch'
+Description-Content-Type: text/markdown
+
+# Valiron
+
+**AI Regulatory Compliance Validation for Python**
+
+Valiron is a Python library that helps ML engineers and data scientists validate their AI/ML models against global regulatory frameworks — before deployment.
+
+---
+
+## Problem
+
+Deploying AI in regulated industries (healthcare, finance, HR) requires compliance with frameworks like the EU AI Act, FDA AI/ML SaMD guidance, CDSCO MDSW, and RBI ML Model Risk guidelines. Manual compliance checks are slow, inconsistent, and expensive.
+
+## Solution
+
+Valiron automates compliance validation with a simple API:
+
+```python
+import valiron
+
+result = valiron.evaluate(
+    model=my_sklearn_model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="eu_ai_act",
+    use_case="medical_diagnosis"
+)
+
+report = valiron.report(result, format="pdf")
+```
+
+---
+
+## Compliance Coverage
+
+| Regulation | Status | Key Checks |
+|---|---|---|
+| EU AI Act Annex III | ✅ | High-risk classification, transparency, human oversight |
+| FDA AI/ML SaMD | ✅ | Predetermined change control, performance monitoring |
+| CDSCO MDSW (India) | ✅ | Software as medical device validation |
+| RBI ML Model Risk | ✅ | Model governance, bias detection, explainability |
+
+---
+
+## Quickstart
+
+```bash
+pip install valiron
+```
+
+```python
+import valiron
+from sklearn.ensemble import RandomForestClassifier
+
+# Train your model
+model = RandomForestClassifier()
+model.fit(X_train, y_train)
+
+# Validate compliance
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="cdsco_mdsw",
+    use_case="diagnostic_aid",
+    sensitive_features=["age", "gender"]
+)
+
+# Check results
+print(result.compliant)          # True/False
+print(result.score)              # 0.0 - 1.0
+print(result.failing_checks)    # list of failed requirements
+
+# Generate report
+valiron.report(result, format="html", output="compliance_report.html")
+```
+
+---
+
+## Supported Frameworks
+
+- scikit-learn
+- PyTorch
+- ONNX
+- Raw predictions (numpy arrays)
+
+---
+
+## Data Privacy Architecture
+
+- **No data leaves your machine.** All validation runs locally.
+- No model weights are transmitted.
+- Reports are generated on-device.
+- Optional: anonymize test data before validation with `valiron.anonymize()`.
+
+---
+
+## Roadmap
+
+- [ ] ISO 42001 (AI Management Systems)
+- [ ] HIPAA AI compliance checks
+- [ ] SEBI AI governance framework
+- [ ] CI/CD integration (GitHub Actions, GitLab CI)
+- [ ] VS Code extension
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE)

valiron-0.1.0/README.md

@@ -0,0 +1,109 @@
+# Valiron
+
+**AI Regulatory Compliance Validation for Python**
+
+Valiron is a Python library that helps ML engineers and data scientists validate their AI/ML models against global regulatory frameworks — before deployment.
+
+---
+
+## Problem
+
+Deploying AI in regulated industries (healthcare, finance, HR) requires compliance with frameworks like the EU AI Act, FDA AI/ML SaMD guidance, CDSCO MDSW, and RBI ML Model Risk guidelines. Manual compliance checks are slow, inconsistent, and expensive.
+
+## Solution
+
+Valiron automates compliance validation with a simple API:
+
+```python
+import valiron
+
+result = valiron.evaluate(
+    model=my_sklearn_model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="eu_ai_act",
+    use_case="medical_diagnosis"
+)
+
+report = valiron.report(result, format="pdf")
+```
+
+---
+
+## Compliance Coverage
+
+| Regulation | Status | Key Checks |
+|---|---|---|
+| EU AI Act Annex III | ✅ | High-risk classification, transparency, human oversight |
+| FDA AI/ML SaMD | ✅ | Predetermined change control, performance monitoring |
+| CDSCO MDSW (India) | ✅ | Software as medical device validation |
+| RBI ML Model Risk | ✅ | Model governance, bias detection, explainability |
+
+---
+
+## Quickstart
+
+```bash
+pip install valiron
+```
+
+```python
+import valiron
+from sklearn.ensemble import RandomForestClassifier
+
+# Train your model
+model = RandomForestClassifier()
+model.fit(X_train, y_train)
+
+# Validate compliance
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="cdsco_mdsw",
+    use_case="diagnostic_aid",
+    sensitive_features=["age", "gender"]
+)
+
+# Check results
+print(result.compliant)          # True/False
+print(result.score)              # 0.0 - 1.0
+print(result.failing_checks)    # list of failed requirements
+
+# Generate report
+valiron.report(result, format="html", output="compliance_report.html")
+```
+
+---
+
+## Supported Frameworks
+
+- scikit-learn
+- PyTorch
+- ONNX
+- Raw predictions (numpy arrays)
+
+---
+
+## Data Privacy Architecture
+
+- **No data leaves your machine.** All validation runs locally.
+- No model weights are transmitted.
+- Reports are generated on-device.
+- Optional: anonymize test data before validation with `valiron.anonymize()`.
+
+---
+
+## Roadmap
+
+- [ ] ISO 42001 (AI Management Systems)
+- [ ] HIPAA AI compliance checks
+- [ ] SEBI AI governance framework
+- [ ] CI/CD integration (GitHub Actions, GitLab CI)
+- [ ] VS Code extension
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE)

valiron-0.1.0/docs/cdsco_guide.md

@@ -0,0 +1,32 @@
+# CDSCO MDSW Compliance Guide
+
+## What is CDSCO MDSW?
+
+CDSCO (Central Drugs Standard Control Organisation) regulates Medical Device Software (MDSW) in India under the Medical Devices Rules, 2017. AI/ML software used for clinical diagnosis or treatment requires compliance.
+
+## Checks Performed by Valiron
+
+| Check | Threshold | Description |
+|---|---|---|
+| `CDSCO_MDSW_PERFORMANCE` | accuracy ≥ 0.70 | Minimum diagnostic accuracy |
+| `CDSCO_MDSW_DATA_PRIVACY` | local only | No patient data transmitted |
+| `CDSCO_MDSW_REGISTRATION` | warning | Reminder to register with CDSCO |
+
+## Usage
+
+```python
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="cdsco_mdsw",
+    use_case="diagnostic_aid",
+)
+```
+
+## Pre-Deployment Checklist
+
+- [ ] Accuracy ≥ 70% on representative Indian patient population
+- [ ] MDSW registered with CDSCO before clinical use
+- [ ] Clinical validation study conducted
+- [ ] Post-market surveillance plan in place

valiron-0.1.0/docs/eu_ai_act_guide.md

@@ -0,0 +1,31 @@
+# EU AI Act Compliance Guide
+
+## Overview
+
+The EU AI Act classifies AI systems by risk. Annex III (high-risk) includes medical devices, employment screening, credit scoring, and biometric identification. High-risk systems face mandatory requirements before EU market placement.
+
+## Checks Performed by Valiron
+
+| Check | Threshold | Description |
+|---|---|---|
+| `EU_AI_ACT_PERFORMANCE` | accuracy ≥ 0.70 | Minimum acceptable performance |
+| `EU_AI_ACT_TRANSPARENCY` | model attribute check | Feature importances or coefficients present |
+| `EU_AI_ACT_HIGH_RISK` | use_case keyword scan | Flags Annex III use cases |
+| `EU_AI_ACT_BIAS` | sensitive_features provided | Fairness audit feasibility |
+
+## Usage
+
+```python
+result = valiron.evaluate(
+    model=model, X_test=X_test, y_test=y_test,
+    regulation="eu_ai_act", use_case="recruitment_screening",
+    sensitive_features=["gender", "age_group"],
+)
+```
+
+## Key Requirements for High-Risk AI
+
+- Human oversight mechanisms
+- Transparency and documentation
+- Data governance and bias checks
+- Technical documentation maintained

valiron-0.1.0/docs/fda_guide.md

@@ -0,0 +1,28 @@
+# FDA AI/ML SaMD Compliance Guide
+
+## Overview
+
+The FDA regulates AI/ML-based Software as a Medical Device (SaMD). The 2021 Action Plan emphasizes a "predetermined change control plan" (PCCP) for adaptive models.
+
+## Checks Performed by Valiron
+
+| Check | Threshold | Description |
+|---|---|---|
+| `FDA_SAMD_PERFORMANCE` | accuracy ≥ 0.75 | Higher bar for medical device context |
+| `FDA_SAMD_PDCP` | warning | Predetermined change control plan required |
+| `FDA_SAMD_MONITORING` | warning | Real-world performance monitoring plan |
+
+## Usage
+
+```python
+result = valiron.evaluate(
+    model=model, X_test=X_test, y_test=y_test,
+    regulation="fda_samd", use_case="diagnostic_imaging_aid",
+)
+```
+
+## Key Requirements
+
+- **PCCP**: document how model updates without new 510(k) submission
+- **Real-World Monitoring**: define post-market drift thresholds
+- **Labelling**: indicate AI/ML nature of device

valiron-0.1.0/examples/finance_model/run.py

@@ -0,0 +1,26 @@
+"""Finance model compliance example — RBI ML Model Risk."""
+
+from sklearn.linear_model import LogisticRegression
+from sklearn.datasets import make_classification
+
+import valiron
+
+X, y = make_classification(n_samples=500, n_features=20, random_state=1)
+X_train, X_test = X[:400], X[400:]
+y_train, y_test = y[:400], y[400:]
+
+model = LogisticRegression(max_iter=200, random_state=1)
+model.fit(X_train, y_train)
+
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="rbi_ml_risk",
+    use_case="credit_scoring",
+)
+
+print(f"Compliant: {result.compliant}")
+print(f"Score:     {result.score:.1%}")
+valiron.report(result, format="html", output="finance_compliance.html")
+print("Report saved to finance_compliance.html")

valiron-0.1.0/examples/healthcare_model/run.py

@@ -0,0 +1,28 @@
+"""Healthcare model compliance example — CDSCO MDSW."""
+
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.datasets import make_classification
+
+import valiron
+
+X, y = make_classification(n_samples=500, n_features=15, random_state=0)
+X_train, X_test = X[:400], X[400:]
+y_train, y_test = y[:400], y[400:]
+
+model = RandomForestClassifier(n_estimators=50, random_state=0)
+model.fit(X_train, y_train)
+
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="cdsco_mdsw",
+    use_case="diagnostic_aid",
+)
+
+print(f"Compliant: {result.compliant}")
+print(f"Score:     {result.score:.1%}")
+print(f"Failing:   {result.failing_checks or 'none'}")
+
+valiron.report(result, format="html", output="healthcare_compliance.html")
+print("Report saved to healthcare_compliance.html")

valiron-0.1.0/examples/hr_model/run.py

@@ -0,0 +1,26 @@
+"""HR model compliance example — EU AI Act (employment/recruitment)."""
+
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.datasets import make_classification
+
+import valiron
+
+X, y = make_classification(n_samples=400, n_features=12, random_state=2)
+X_train, X_test = X[:300], X[300:]
+y_train, y_test = y[:300], y[300:]
+
+model = DecisionTreeClassifier(max_depth=5, random_state=2)
+model.fit(X_train, y_train)
+
+result = valiron.evaluate(
+    model=model,
+    X_test=X_test,
+    y_test=y_test,
+    regulation="eu_ai_act",
+    use_case="recruitment_screening",
+    sensitive_features=["gender", "age_group"],
+)
+
+print(f"Compliant: {result.compliant}")
+print(f"Score:     {result.score:.1%}")
+valiron.report(result, format="html", output="hr_compliance.html")

valiron-0.1.0/pyproject.toml

@@ -0,0 +1,57 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "valiron"
+version = "0.1.0"
+description = "AI regulatory compliance validation for Python"
+readme = "README.md"
+license = { file = "LICENSE" }
+authors = [{ name = "Abhay Sachan" }]
+requires-python = ">=3.9"
+keywords = ["ai", "compliance", "regulation", "ml", "validation"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "numpy>=1.21",
+    "pandas>=1.3",
+    "scikit-learn>=1.0",
+    "scipy>=1.7",
+    "jinja2>=3.0",
+]
+
+[project.optional-dependencies]
+onnx = ["onnxruntime>=1.12"]
+torch = ["torch>=1.10"]
+pdf = ["weasyprint>=57"]
+dev = [
+    "pytest>=7",
+    "pytest-cov>=4",
+    "ruff>=0.1",
+    "mypy>=1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/abhaysachan007/valiron"
+Issues = "https://github.com/abhaysachan007/valiron/issues"
+
+[tool.hatch.build.targets.wheel]
+packages = ["valiron"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+addopts = "--cov=valiron --cov-report=term-missing"
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.mypy]
+python_version = "3.9"
+strict = true

valiron-0.1.0/tests/test_calibration.py

@@ -0,0 +1,30 @@
+"""Tests for calibration checker."""
+
+import numpy as np
+
+from valiron.calibration.checker import check_calibration, CalibrationResult
+
+
+def test_perfect_calibration():
+    y_true = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
+    y_prob = np.array([0.1, 0.9, 0.1, 0.9, 0.1, 0.9, 0.1, 0.9, 0.1, 0.9])
+    result = check_calibration(y_true, y_prob)
+    assert isinstance(result, CalibrationResult)
+    assert result.well_calibrated is True
+
+
+def test_poor_calibration():
+    y_true = np.zeros(100)
+    y_prob = np.ones(100) * 0.9
+    result = check_calibration(y_true, y_prob)
+    assert result.expected_calibration_error > 0.5
+    assert result.well_calibrated is False
+
+
+def test_ece_range():
+    rng = np.random.default_rng(42)
+    y_true = rng.integers(0, 2, size=200)
+    y_prob = rng.random(200)
+    result = check_calibration(y_true, y_prob)
+    assert 0.0 <= result.expected_calibration_error <= 1.0
+    assert 0.0 <= result.max_calibration_error <= 1.0

valiron-0.1.0/tests/test_evaluate.py

@@ -0,0 +1,47 @@
+"""Tests for valiron.evaluate()."""
+
+import pytest
+from sklearn.dummy import DummyClassifier
+from sklearn.datasets import make_classification
+
+import valiron
+from valiron.evaluate.runner import EvaluationResult, SUPPORTED_REGULATIONS
+
+
+@pytest.fixture
+def simple_model():
+    X, y = make_classification(n_samples=200, n_features=10, random_state=42)
+    model = DummyClassifier(strategy="most_frequent")
+    model.fit(X[:100], y[:100])
+    return model, X[100:], y[100:]
+
+
+def test_evaluate_returns_result(simple_model):
+    model, X_test, y_test = simple_model
+    result = valiron.evaluate(model, X_test, y_test, "eu_ai_act", "generic classification")
+    assert isinstance(result, EvaluationResult)
+
+
+def test_evaluate_score_range(simple_model):
+    model, X_test, y_test = simple_model
+    result = valiron.evaluate(model, X_test, y_test, "rbi_ml_risk", "credit scoring")
+    assert 0.0 <= result.score <= 1.0
+
+
+def test_evaluate_unknown_regulation_raises(simple_model):
+    model, X_test, y_test = simple_model
+    with pytest.raises(ValueError, match="Unknown regulation"):
+        valiron.evaluate(model, X_test, y_test, "unknown_reg", "test")
+
+
+def test_all_regulations_run(simple_model):
+    model, X_test, y_test = simple_model
+    for reg in SUPPORTED_REGULATIONS:
+        result = valiron.evaluate(model, X_test, y_test, reg, "test case")
+        assert result.regulation == reg
+
+
+def test_compliant_flag_consistent(simple_model):
+    model, X_test, y_test = simple_model
+    result = valiron.evaluate(model, X_test, y_test, "cdsco_mdsw", "diagnostic aid")
+    assert result.compliant == (len(result.failing_checks) == 0)

valiron-0.1.0/tests/test_report.py

@@ -0,0 +1,41 @@
+"""Tests for report builder."""
+
+import pytest
+
+from valiron.evaluate.runner import EvaluationResult
+from valiron.report.builder import report
+
+
+def _make_result(**kwargs):
+    defaults = dict(
+        regulation="eu_ai_act", use_case="test", compliant=True, score=0.9,
+        passing_checks=["CHECK_A"], failing_checks=[], warnings=["WARN_1"],
+    )
+    defaults.update(kwargs)
+    return EvaluationResult(**defaults)
+
+
+def test_report_returns_html_string():
+    html = report(_make_result())
+    assert isinstance(html, str)
+    assert "<html" in html.lower()
+
+
+def test_report_contains_regulation():
+    html = report(_make_result(regulation="cdsco_mdsw"))
+    assert "cdsco_mdsw" in html
+
+
+def test_report_shows_compliant():
+    assert "COMPLIANT" in report(_make_result(compliant=True))
+
+
+def test_report_shows_non_compliant():
+    html = report(_make_result(compliant=False, failing_checks=["FAIL_X"]))
+    assert "NON-COMPLIANT" in html
+    assert "FAIL_X" in html
+
+
+def test_report_unsupported_format_raises():
+    with pytest.raises(ValueError, match="Unsupported format"):
+        report(_make_result(), format="xml")

valiron-0.1.0/tests/test_subgroups.py

@@ -0,0 +1,33 @@
+"""Tests for subgroup fairness analysis."""
+
+import numpy as np
+import pandas as pd
+
+from valiron.subgroups.analyzer import analyze_subgroups
+
+
+def test_basic_subgroup_analysis():
+    y_true = np.array([1, 1, 0, 0, 1, 0])
+    y_pred = np.array([1, 1, 0, 0, 0, 1])
+    df = pd.DataFrame({"gender": ["M", "M", "F", "F", "M", "F"]})
+    result = analyze_subgroups(y_true, y_pred, df)
+    assert "gender" in result
+    assert "M" in result["gender"]
+    assert "F" in result["gender"]
+
+
+def test_accuracy_in_range():
+    y_true = np.array([1, 0, 1, 0])
+    y_pred = np.array([1, 0, 0, 1])
+    df = pd.DataFrame({"group": ["A", "A", "B", "B"]})
+    result = analyze_subgroups(y_true, y_pred, df)
+    for val in result["group"].values():
+        assert 0.0 <= val <= 1.0
+
+
+def test_feature_subset():
+    df = pd.DataFrame({"age": ["young", "old", "young"], "gender": ["M", "F", "M"]})
+    y = np.array([1, 0, 1])
+    result = analyze_subgroups(y, y, df, features=["age"])
+    assert "age" in result
+    assert "gender" not in result

valiron-0.1.0/valiron/__init__.py

@@ -0,0 +1,7 @@
+"""Valiron — AI regulatory compliance validation."""
+
+from valiron.evaluate.runner import evaluate
+from valiron.report.builder import report
+
+__all__ = ["evaluate", "report"]
+__version__ = "0.1.0"

valiron-0.1.0/valiron/acp/__init__.py

@@ -0,0 +1 @@
+"""ACP — Audit Control Plane for logging and evidence collection."""

valiron-0.1.0/valiron/calibration/__init__.py

@@ -0,0 +1,5 @@
+"""Calibration checks — reliability of predicted probabilities."""
+
+from valiron.calibration.checker import check_calibration
+
+__all__ = ["check_calibration"]

valiron-0.1.0/valiron/calibration/checker.py

@@ -0,0 +1,39 @@
+"""Probability calibration checker."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass
+class CalibrationResult:
+    expected_calibration_error: float
+    max_calibration_error: float
+    well_calibrated: bool
+
+
+def check_calibration(y_true: Any, y_prob: Any, n_bins: int = 10) -> CalibrationResult:
+    """Compute ECE and MCE for probability calibration assessment."""
+    y_true = np.asarray(y_true, dtype=float)
+    y_prob = np.asarray(y_prob, dtype=float)
+    bins = np.linspace(0.0, 1.0, n_bins + 1)
+    ece = 0.0
+    mce = 0.0
+    n = len(y_true)
+
+    for low, high in zip(bins[:-1], bins[1:]):
+        mask = (y_prob >= low) & (y_prob < high)
+        if mask.sum() == 0:
+            continue
+        gap = abs(float(np.mean(y_true[mask])) - float(np.mean(y_prob[mask])))
+        ece += gap * mask.sum() / n
+        mce = max(mce, gap)
+
+    return CalibrationResult(
+        expected_calibration_error=round(ece, 4),
+        max_calibration_error=round(mce, 4),
+        well_calibrated=ece < 0.1,
+    )

valiron-0.1.0/valiron/evaluate/__init__.py

@@ -0,0 +1,5 @@
+"""Evaluate module — runs compliance checks against a regulation."""
+
+from valiron.evaluate.runner import evaluate
+
+__all__ = ["evaluate"]

valiron-0.1.0/valiron/evaluate/checks.py

@@ -0,0 +1,117 @@
+"""Per-regulation compliance checks."""
+
+from __future__ import annotations
+
+from typing import Any, List, Tuple
+
+import numpy as np
+
+
+def run_checks(
+    model: Any,
+    X_test: Any,
+    y_test: Any,
+    regulation: str,
+    use_case: str,
+    sensitive_features: List[str],
+    feature_names: List[str],
+) -> Tuple[List[str], List[str], List[str]]:
+    """Run all checks for *regulation*, return (passing, failing, warnings)."""
+    registry = {
+        "eu_ai_act": _eu_ai_act_checks,
+        "fda_samd": _fda_samd_checks,
+        "cdsco_mdsw": _cdsco_mdsw_checks,
+        "rbi_ml_risk": _rbi_ml_risk_checks,
+    }
+    return registry[regulation](model, X_test, y_test, use_case, sensitive_features)
+
+
+def _predict(model: Any, X: Any) -> Any:
+    if hasattr(model, "predict"):
+        return model.predict(X)
+    if callable(model):
+        return model(X)
+    raise TypeError(f"Cannot get predictions from {type(model)}")
+
+
+def _accuracy(y_true: Any, y_pred: Any) -> float:
+    y_true = np.asarray(y_true)
+    y_pred = np.asarray(y_pred)
+    return float(np.mean(y_true == y_pred))
+
+
+def _eu_ai_act_checks(model, X_test, y_test, use_case, sensitive_features):
+    passing, failing, warnings = [], [], []
+    try:
+        acc = _accuracy(y_test, _predict(model, X_test))
+        if acc >= 0.7:
+            passing.append(f"EU_AI_ACT_PERFORMANCE: accuracy={acc:.3f} >= 0.70")
+        else:
+            failing.append(f"EU_AI_ACT_PERFORMANCE: accuracy={acc:.3f} < 0.70")
+    except Exception as e:
+        failing.append(f"EU_AI_ACT_PERFORMANCE: {e}")
+
+    if hasattr(model, "feature_importances_") or hasattr(model, "coef_"):
+        passing.append("EU_AI_ACT_TRANSPARENCY: model exposes feature importances")
+    else:
+        warnings.append("EU_AI_ACT_TRANSPARENCY: model has no native explainability")
+
+    high_risk = ("medical", "health", "diagnostic", "credit", "employment", "biometric")
+    if any(kw in use_case.lower() for kw in high_risk):
+        warnings.append("EU_AI_ACT_HIGH_RISK: use case may be Annex III high-risk")
+    else:
+        passing.append("EU_AI_ACT_HIGH_RISK: not flagged as high-risk")
+
+    if sensitive_features:
+        passing.append(f"EU_AI_ACT_BIAS: sensitive features provided {sensitive_features}")
+    else:
+        warnings.append("EU_AI_ACT_BIAS: no sensitive_features supplied; fairness audit skipped")
+
+    return passing, failing, warnings
+
+
+def _fda_samd_checks(model, X_test, y_test, use_case, sensitive_features):
+    passing, failing, warnings = [], [], []
+    try:
+        acc = _accuracy(y_test, _predict(model, X_test))
+        (passing if acc >= 0.75 else failing).append(
+            f"FDA_SAMD_PERFORMANCE: accuracy={acc:.3f} {'>=0.75' if acc >= 0.75 else '<0.75'}"
+        )
+    except Exception as e:
+        failing.append(f"FDA_SAMD_PERFORMANCE: {e}")
+    warnings.append("FDA_SAMD_PDCP: predetermined change control plan required")
+    warnings.append("FDA_SAMD_MONITORING: real-world performance monitoring required")
+    return passing, failing, warnings
+
+
+def _cdsco_mdsw_checks(model, X_test, y_test, use_case, sensitive_features):
+    passing, failing, warnings = [], [], []
+    try:
+        acc = _accuracy(y_test, _predict(model, X_test))
+        (passing if acc >= 0.70 else failing).append(
+            f"CDSCO_MDSW_PERFORMANCE: accuracy={acc:.3f}"
+        )
+    except Exception as e:
+        failing.append(f"CDSCO_MDSW_PERFORMANCE: {e}")
+    warnings.append("CDSCO_MDSW_REGISTRATION: MDSW registration with CDSCO required")
+    passing.append("CDSCO_MDSW_DATA_PRIVACY: local evaluation — no patient data transmitted")
+    return passing, failing, warnings
+
+
+def _rbi_ml_risk_checks(model, X_test, y_test, use_case, sensitive_features):
+    passing, failing, warnings = [], [], []
+    try:
+        acc = _accuracy(y_test, _predict(model, X_test))
+        (passing if acc >= 0.65 else failing).append(
+            f"RBI_ML_PERFORMANCE: accuracy={acc:.3f}"
+        )
+    except Exception as e:
+        failing.append(f"RBI_ML_PERFORMANCE: {e}")
+
+    if hasattr(model, "feature_importances_") or hasattr(model, "coef_"):
+        passing.append("RBI_ML_EXPLAINABILITY: model supports explainability")
+    else:
+        failing.append("RBI_ML_EXPLAINABILITY: model must support explainability")
+
+    warnings.append("RBI_ML_GOVERNANCE: model risk management documentation required")
+    return passing, failing, warnings

valiron-0.1.0/valiron/evaluate/runner.py

@@ -0,0 +1,62 @@
+"""Main evaluate() entry point."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, List, Optional
+
+
+SUPPORTED_REGULATIONS = ("eu_ai_act", "fda_samd", "cdsco_mdsw", "rbi_ml_risk")
+
+
+@dataclass
+class EvaluationResult:
+    regulation: str
+    use_case: str
+    compliant: bool
+    score: float
+    passing_checks: List[str] = field(default_factory=list)
+    failing_checks: List[str] = field(default_factory=list)
+    warnings: List[str] = field(default_factory=list)
+    metadata: dict = field(default_factory=dict)
+
+
+def evaluate(
+    model: Any,
+    X_test: Any,
+    y_test: Any,
+    regulation: str,
+    use_case: str,
+    sensitive_features: Optional[List[str]] = None,
+    feature_names: Optional[List[str]] = None,
+) -> EvaluationResult:
+    """Validate model against regulation for use_case."""
+    if regulation not in SUPPORTED_REGULATIONS:
+        raise ValueError(
+            f"Unknown regulation '{regulation}'. Supported: {SUPPORTED_REGULATIONS}"
+        )
+
+    from valiron.evaluate.checks import run_checks
+
+    passing, failing, warnings = run_checks(
+        model=model,
+        X_test=X_test,
+        y_test=y_test,
+        regulation=regulation,
+        use_case=use_case,
+        sensitive_features=sensitive_features or [],
+        feature_names=feature_names or [],
+    )
+
+    total = len(passing) + len(failing)
+    score = len(passing) / total if total > 0 else 0.0
+
+    return EvaluationResult(
+        regulation=regulation,
+        use_case=use_case,
+        compliant=len(failing) == 0,
+        score=round(score, 4),
+        passing_checks=passing,
+        failing_checks=failing,
+        warnings=warnings,
+    )

valiron-0.1.0/valiron/report/__init__.py

@@ -0,0 +1,5 @@
+"""Report generation — HTML and PDF compliance reports."""
+
+from valiron.report.builder import report
+
+__all__ = ["report"]

valiron-0.1.0/valiron/report/builder.py

@@ -0,0 +1,43 @@
+"""Compliance report builder."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+from jinja2 import Environment, FileSystemLoader
+
+from valiron.evaluate.runner import EvaluationResult
+
+
+_TEMPLATES_DIR = Path(__file__).parent / "templates"
+
+
+def report(
+    result: EvaluationResult,
+    format: str = "html",
+    output: Optional[str] = None,
+) -> str:
+    """Generate a compliance report from an EvaluationResult."""
+    if format not in ("html", "pdf"):
+        raise ValueError(f"Unsupported format '{format}'. Use 'html' or 'pdf'.")
+
+    env = Environment(loader=FileSystemLoader(str(_TEMPLATES_DIR)), autoescape=True)
+    template = env.get_template("report.html.j2")
+    html = template.render(result=result)
+
+    if format == "pdf":
+        try:
+            from weasyprint import HTML as WeasyprintHTML
+        except ImportError:
+            raise ImportError("PDF export requires weasyprint: pip install valiron[pdf]")
+        pdf_bytes = WeasyprintHTML(string=html).write_pdf()
+        out_path = output or "compliance_report.pdf"
+        Path(out_path).write_bytes(pdf_bytes)
+        return out_path
+
+    if output:
+        Path(output).write_text(html, encoding="utf-8")
+        return output
+
+    return html

valiron-0.1.0/valiron/report/templates/report.html.j2

@@ -0,0 +1,59 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Valiron Compliance Report — {{ result.regulation }}</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 900px; margin: 40px auto; padding: 0 20px; color: #1a1a1a; }
+    h1 { border-bottom: 2px solid #333; padding-bottom: 8px; }
+    .badge { display: inline-block; padding: 4px 12px; border-radius: 4px; font-weight: bold; }
+    .compliant { background: #d4edda; color: #155724; }
+    .non-compliant { background: #f8d7da; color: #721c24; }
+    .score { font-size: 2em; font-weight: bold; margin: 16px 0; }
+    table { width: 100%; border-collapse: collapse; margin-top: 16px; }
+    th, td { padding: 8px 12px; border: 1px solid #dee2e6; text-align: left; }
+    th { background: #f8f9fa; }
+    .pass { color: #155724; }
+    .fail { color: #721c24; font-weight: bold; }
+    .warn { color: #856404; }
+    footer { margin-top: 40px; font-size: 0.8em; color: #6c757d; }
+  </style>
+</head>
+<body>
+  <h1>Valiron Compliance Report</h1>
+  <p><strong>Regulation:</strong> {{ result.regulation }}</p>
+  <p><strong>Use Case:</strong> {{ result.use_case }}</p>
+  <p><strong>Status:</strong>
+    <span class="badge {{ 'compliant' if result.compliant else 'non-compliant' }}">
+      {{ 'COMPLIANT' if result.compliant else 'NON-COMPLIANT' }}
+    </span>
+  </p>
+  <p class="score">Score: {{ (result.score * 100) | round(1) }}%</p>
+
+  {% if result.failing_checks %}
+  <h2>Failing Checks</h2>
+  <table><tr><th>Check</th></tr>
+  {% for check in result.failing_checks %}
+  <tr><td class="fail">✗ {{ check }}</td></tr>
+  {% endfor %}</table>
+  {% endif %}
+
+  {% if result.passing_checks %}
+  <h2>Passing Checks</h2>
+  <table><tr><th>Check</th></tr>
+  {% for check in result.passing_checks %}
+  <tr><td class="pass">✓ {{ check }}</td></tr>
+  {% endfor %}</table>
+  {% endif %}
+
+  {% if result.warnings %}
+  <h2>Warnings</h2>
+  <table><tr><th>Warning</th></tr>
+  {% for w in result.warnings %}
+  <tr><td class="warn">⚠ {{ w }}</td></tr>
+  {% endfor %}</table>
+  {% endif %}
+
+  <footer>Generated by <strong>Valiron</strong> — AI Regulatory Compliance Validation</footer>
+</body>
+</html>

valiron-0.1.0/valiron/subgroups/__init__.py

@@ -0,0 +1,5 @@
+"""Subgroup analysis — fairness checks across demographic slices."""
+
+from valiron.subgroups.analyzer import analyze_subgroups
+
+__all__ = ["analyze_subgroups"]

valiron-0.1.0/valiron/subgroups/analyzer.py

@@ -0,0 +1,33 @@
+"""Subgroup fairness analysis."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import numpy as np
+import pandas as pd
+
+
+def analyze_subgroups(
+    y_true: Any,
+    y_pred: Any,
+    sensitive_df: pd.DataFrame,
+    features: Optional[List[str]] = None,
+) -> Dict[str, Dict[str, float]]:
+    """Compute per-subgroup accuracy for each sensitive feature."""
+    y_true = np.asarray(y_true)
+    y_pred = np.asarray(y_pred)
+    cols = features or list(sensitive_df.columns)
+    results: Dict[str, Dict[str, float]] = {}
+
+    for col in cols:
+        group_accs: Dict[str, float] = {}
+        for val in sensitive_df[col].unique():
+            mask = sensitive_df[col] == val
+            if mask.sum() == 0:
+                continue
+            acc = float(np.mean(y_true[mask] == y_pred[mask]))
+            group_accs[str(val)] = round(acc, 4)
+        results[col] = group_accs
+
+    return results