ai-critic 0.1.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

ai_critic/critic.py

@@ -4,10 +4,13 @@ from ai_critic.evaluators import (
     data,
     performance
 )
+from ai_critic.evaluators.summary import HumanSummary
+
 
 class AICritic:
     """
-    Orquestrador principal da avaliação de modelos sklearn
+    Automated reviewer for scikit-learn models.
+    Produces a multi-layered risk assessment with visualizations.
     """
 
     def __init__(self, model, X, y):
@@ -15,16 +18,70 @@ class AICritic:
         self.X = X
         self.y = y
 
-    def evaluate(self):
-        report = {}
+    def evaluate(self, view="all", plot=False):
+        """
+        view:
+            - "all"
+            - "executive"
+            - "technical"
+            - "details"
+            - list of views
+        plot:
+            - True: gera gráficos de learning curve, heatmap e robustez
+            - False: sem gráficos
+        """
+
+        # =========================
+        # Low-level technical details
+        # =========================
+        details = {}
+
+        # Data analysis + heatmap
+        data_report = data(self.X, self.y, plot=plot)
+        details["data"] = data_report
+
+        # Model configuration
+        details["config"] = config(
+            self.model,
+            n_samples=data_report["n_samples"],
+            n_features=data_report["n_features"]
+        )
 
-        report["config"] = config(self.model)
-        report["data"] = data(self.X, self.y)
-        report["performance"] = performance(
-            self.model, self.X, self.y
+        # Performance + learning curve
+        details["performance"] = performance(
+            self.model, self.X, self.y, plot=plot
         )
-        report["robustness"] = robustness(
-            self.model, self.X, self.y
+
+        # Robustness + CV clean vs noisy
+        details["robustness"] = robustness(
+            self.model,
+            self.X,
+            self.y,
+            leakage_suspected=data_report["data_leakage"]["suspected"],
+            plot=plot
         )
 
-        return report
+        # =========================
+        # Human interpretation
+        # =========================
+        human = HumanSummary().generate(details)
+
+        # =========================
+        # Full payload
+        # =========================
+        payload = {
+            "executive": human["executive_summary"],
+            "technical": human["technical_summary"],
+            "details": details
+        }
+
+        # =========================
+        # View selector
+        # =========================
+        if view == "all":
+            return payload
+
+        if isinstance(view, list):
+            return {k: payload[k] for k in view if k in payload}
+
+        return payload.get(view)

ai_critic/evaluators/config.py

@@ -1,6 +1,35 @@
-def evaluate(model):
-    return {
-        "model_type": type(model).__name__,
-        "n_params": len(model.get_params()),
-        "uses_random_state": "random_state" in model.get_params()
+import math
+
+def evaluate(model, n_samples=None, n_features=None):
+    params = model.get_params()
+    model_type = type(model).__name__
+
+    report = {
+        "model_type": model_type,
+        "n_params": len(params),
+        "uses_random_state": "random_state" in params
     }
+
+    # 🧠 Structural overfitting heuristics
+    warnings = []
+
+    if n_samples and hasattr(model, "max_depth"):
+        max_depth = params.get("max_depth")
+        if max_depth is not None:
+            recommended_depth = math.log2(n_samples)
+            if max_depth > recommended_depth:
+                warnings.append({
+                    "issue": "structural_overfitting_risk",
+                    "max_depth": max_depth,
+                    "recommended_max_depth": int(recommended_depth),
+                    "message": "Tree depth may be too high for dataset size."
+                })
+
+    if n_samples and n_features and n_features > n_samples:
+        warnings.append({
+            "issue": "high_feature_sample_ratio",
+            "message": "More features than samples can cause instability."
+        })
+
+    report["structural_warnings"] = warnings
+    return report

ai_critic/evaluators/data.py

@@ -1,14 +1,57 @@
 import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import pandas as pd
 
-def evaluate(X, y):
-    return {
-        "n_samples": X.shape[0],
-        "n_features": X.shape[1],
-        "has_nan": bool(
-            np.isnan(X).any() or np.isnan(y).any()
-        ),
-        "class_balance": (
-            dict(zip(*np.unique(y, return_counts=True)))
-            if len(set(y)) < 20 else "many_classes"
+def evaluate(X, y, plot=False):
+    report = {
+        "n_samples": int(X.shape[0]),
+        "n_features": int(X.shape[1]),
+        "has_nan": bool(np.isnan(X).any() or np.isnan(y).any())
+    }
+
+    # Class balance
+    if len(set(y)) < 20:
+        values, counts = np.unique(y, return_counts=True)
+        report["class_balance"] = {int(v): int(c) for v, c in zip(values, counts)}
+    else:
+        report["class_balance"] = "many_classes"
+
+    # Data leakage detection
+    suspicious_features = []
+    y_mean = np.mean(y)
+    y_centered = y - y_mean
+    for i in range(X.shape[1]):
+        feature = X[:, i]
+        if np.std(feature) == 0:
+            continue
+        corr = np.corrcoef(feature, y_centered)[0, 1]
+        if abs(corr) > 0.98:
+            suspicious_features.append({"feature_index": int(i), "correlation": float(corr)})
+
+    report["data_leakage"] = {
+        "suspected": bool(len(suspicious_features) > 0),
+        "details": suspicious_features,
+        "message": (
+            "Highly correlated features may reveal the target directly."
+            if suspicious_features else "No obvious data leakage detected."
         )
     }
+
+    # =========================
+    # Heatmap de correlação Features x Target
+    # =========================
+    if plot:
+        feature_names = [f"feat_{i}" for i in range(X.shape[1])]
+        df = pd.DataFrame(X, columns=feature_names)
+        df['target'] = y
+        corr_matrix = df.corr()
+
+        plt.figure(figsize=(10,8))
+        sns.heatmap(corr_matrix, annot=False, cmap="coolwarm")  # <- removi os números
+        plt.title("Correlação Features x Target")
+        plt.tight_layout()
+        plt.savefig("heatmap_correlation.png", dpi=150)  # Salva automaticamente
+        plt.show()
+
+    return report

ai_critic/evaluators/performance.py

@@ -1,11 +1,43 @@
-from sklearn.model_selection import cross_val_score
+from sklearn.model_selection import cross_val_score, learning_curve
+import matplotlib.pyplot as plt
+import numpy as np
 
-def evaluate(model, X, y):
-    scores = cross_val_score(
-        model, X, y, cv=3, n_jobs=1
-    )
+def evaluate(model, X, y, plot=False):
+    # CV básico
+    scores = cross_val_score(model, X, y, cv=3)
+    mean = float(scores.mean())
+    std = float(scores.std())
+    suspicious = mean > 0.995
 
-    return {
-        "cv_mean_score": float(scores.mean()),
-        "cv_std": float(scores.std())
+    result = {
+        "cv_mean_score": mean,
+        "cv_std": std,
+        "suspiciously_perfect": suspicious,
+        "message": (
+            "Perfect CV score detected — possible data leakage."
+            if suspicious else "CV performance within expected range."
+        )
     }
+
+    # =========================
+    # Learning curve
+    # =========================
+    if plot:
+        train_sizes, train_scores, test_scores = learning_curve(
+            model, X, y, cv=3, train_sizes=np.linspace(0.1, 1.0, 5)
+        )
+        plt.figure(figsize=(6,4))
+        plt.plot(train_sizes, np.mean(train_scores, axis=1), label="Treino")
+        plt.plot(train_sizes, np.mean(test_scores, axis=1), label="Validação")
+        plt.fill_between(train_sizes,
+                         np.mean(test_scores, axis=1)-np.std(test_scores, axis=1),
+                         np.mean(test_scores, axis=1)+np.std(test_scores, axis=1),
+                         alpha=0.2)
+        plt.xlabel("Amostra de treino")
+        plt.ylabel("Score")
+        plt.title("Learning Curve")
+        plt.legend()
+        plt.tight_layout()
+        plt.show()
+
+    return result

ai_critic/evaluators/robustness.py

@@ -1,18 +1,54 @@
 import numpy as np
 from sklearn.base import clone
+from sklearn.model_selection import cross_val_score
+import matplotlib.pyplot as plt
 
-def evaluate(model, X, y):
-    model_1 = clone(model)
-    model_2 = clone(model)
+def evaluate(model, X, y, leakage_suspected=False, plot=False):
+    noise_level = 0.02  # 2% relative noise
+    scale = np.std(X)
+    noise = np.random.normal(0, noise_level * scale, X.shape)
+    X_noisy = X + noise
 
-    model_1.fit(X, y)
-    model_2.fit(X + np.random.normal(0, 1e-6, X.shape), y)
+    model_clean = clone(model)
+    model_noisy = clone(model)
 
-    score_1 = model_1.score(X, y)
-    score_2 = model_2.score(X, y)
+    score_clean = cross_val_score(model_clean, X, y, cv=3, n_jobs=1).mean()
+    score_noisy = cross_val_score(model_noisy, X_noisy, y, cv=3, n_jobs=1).mean()
+    drop = score_clean - score_noisy
+
+    # =========================
+    # Verdict
+    # =========================
+    if leakage_suspected and score_clean > 0.98:
+        verdict = "misleading"
+        message = (
+            "Model appears robust to noise, but original performance is "
+            "likely inflated due to data leakage."
+        )
+    elif drop > 0.15:
+        verdict = "fragile"
+        message = "Model performance degrades significantly under noise."
+    else:
+        verdict = "stable"
+        message = "Model shows acceptable robustness to noise."
+
+    # =========================
+    # Plot CV Clean vs Noisy
+    # =========================
+    if plot:
+        plt.figure(figsize=(4,4))
+        plt.bar(["Original", "Com Ruído"], [score_clean, score_noisy], color=['green','red'])
+        plt.ylabel("CV Score")
+        plt.title("Robustez do Modelo")
+        plt.ylim(0, 1)
+        plt.tight_layout()
+        plt.savefig("robustness.png", dpi=150)  # Salva automaticamente
+        plt.show()
 
     return {
-        "score_original": float(score_1),
-        "score_perturbed": float(score_2),
-        "delta": float(abs(score_1 - score_2))
+        "cv_score_original": float(score_clean),
+        "cv_score_noisy": float(score_noisy),
+        "performance_drop": float(drop),
+        "verdict": verdict,
+        "message": message
     }

ai_critic/evaluators/summary.py

@@ -0,0 +1,96 @@
+class HumanSummary:
+    """
+    Builds a hierarchical, human-centered interpretation
+    of the AI Critic technical report.
+    """
+
+    def generate(self, report: dict) -> dict:
+        leakage = report["data"]["data_leakage"]["suspected"]
+        perfect_cv = report["performance"]["suspiciously_perfect"]
+        robustness_verdict = report["robustness"].get("verdict")
+        structural_warnings = report["config"]["structural_warnings"]
+
+        # =========================
+        # Executive summary
+        # =========================
+        if leakage and perfect_cv:
+            verdict = "❌ Unreliable"
+            risk_level = "high"
+            deploy = False
+            main_reason = "Strong evidence of data leakage inflating model performance."
+        elif robustness_verdict in ("fragile", "misleading") or structural_warnings:
+            verdict = "⚠️ Risky"
+            risk_level = "medium"
+            deploy = False
+            main_reason = "Structural or robustness-related risks detected."
+        else:
+            verdict = "✅ Acceptable"
+            risk_level = "low"
+            deploy = True
+            main_reason = "No critical risks detected."
+
+        executive_summary = {
+            "verdict": verdict,
+            "risk_level": risk_level,
+            "deploy_recommended": deploy,
+            "main_reason": main_reason,
+            "one_line_explanation": (
+                "Although validation accuracy is extremely high, multiple signals "
+                "indicate that the model does not generalize reliably."
+                if verdict == "❌ Unreliable"
+                else
+                "The model shows acceptable behavior under current evaluation heuristics."
+            )
+        }
+
+        # =========================
+        # Technical summary
+        # =========================
+        key_risks = []
+        recommendations = []
+
+        if leakage:
+            key_risks.append(
+                "Data leakage suspected due to near-perfect feature–target correlation."
+            )
+            recommendations.append(
+                "Audit and remove features highly correlated with the target."
+            )
+
+        if perfect_cv:
+            key_risks.append(
+                "Perfect cross-validation score detected (statistically unlikely)."
+            )
+            recommendations.append(
+                "Re-run validation after leakage mitigation."
+            )
+
+        for w in structural_warnings:
+            key_risks.append(w["message"])
+            recommendations.append(
+                "Reduce model complexity or adjust hyperparameters."
+            )
+
+        if robustness_verdict == "misleading":
+            key_risks.append(
+                "Robustness metrics are misleading due to inflated baseline performance."
+            )
+            recommendations.append(
+                "Fix baseline performance issues before trusting robustness metrics."
+            )
+
+        technical_summary = {
+            "key_risks": key_risks or ["No significant risks detected."],
+            "model_health": {
+                "data_leakage": leakage,
+                "suspicious_cv": perfect_cv,
+                "structural_risk": bool(structural_warnings),
+                "robustness_verdict": robustness_verdict
+            },
+            "recommendations": recommendations
+        }
+
+        return {
+            "executive_summary": executive_summary,
+            "technical_summary": technical_summary
+        }

ai_critic-0.2.1.dist-info/METADATA

@@ -0,0 +1,258 @@
+Metadata-Version: 2.4
+Name: ai-critic
+Version: 0.2.1
+Summary: Fast AI evaluator for scikit-learn models
+Author-email: Luiz Seabra <filipedemarco@yahoo.com>
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: scikit-learn
+
+# ai-critic: Automated Risk Auditor for Machine Learning Models**
+
+---
+
+## 🚀 What is ai-critic?
+
+`ai-critic` é um **auditor de risco automatizado baseado em heurísticas** para modelos de *machine learning*. Ele avalia modelos treinados antes da implantação e traduz riscos técnicos de ML em decisões claras e centradas no ser humano.
+
+Em vez de apenas relatar métricas, o `ai-critic` responde à pergunta crítica:
+
+> “Este modelo pode ser implantado com segurança?”
+
+Ele faz isso analisando as principais áreas de risco:
+
+*   **Integridade dos Dados:** (*data leakage*, desequilíbrio, NaNs)
+*   **Estrutura do Modelo:** (risco de *overfitting*, complexidade)
+*   **Comportamento de Validação:** (pontuações suspeitamente perfeitas)
+*   **Robustez:** (sensibilidade a ruído)
+
+Os resultados são organizados em três camadas semânticas para diferentes *stakeholders*:
+
+*   **Executiva:** (tomadores de decisão)
+*   **Técnica:** (engenheiros de ML)
+*   **Detalhada:** (auditores e depuração)
+
+## 🎯 Por que o ai-critic Existe: Filosofia Central
+
+A maioria das ferramentas de ML:
+
+*   assume que métricas = verdade
+*   confia cegamente na validação cruzada
+*   despeja números brutos sem interpretação
+
+O `ai-critic` é cético por design.
+
+Ele trata:
+
+*   pontuações perfeitas como **sinais**, não sucesso
+*   métricas de robustez como **dependentes do contexto**
+*   implantação como uma **decisão de risco**, não um limite de métrica
+
+A filosofia central é: **Métricas não falham modelos — o contexto falha.**
+
+O `ai-critic` aplica heurísticas de raciocínio humano à avaliação de ML:
+
+*   “Isso é bom demais para ser verdade?”
+*   “Isso pode estar vazando o alvo (*target*)?”
+*   “A robustez importa se a linha de base estiver errada?”
+
+## 🛠️ Instalação
+
+Instale o `ai-critic` via pip:
+
+```bash
+pip install ai-critic
+```
+
+**Requisitos:**
+
+*   Python ≥ 3.8
+*   `scikit-learn`
+
+## 💡 Início Rápido
+
+Audite seu modelo treinado em apenas algumas linhas:
+
+```python
+from sklearn.datasets import load_breast_cancer
+from sklearn.ensemble import RandomForestClassifier
+from ai_critic import AICritic
+
+# 1. Carregar dados e treinar um modelo (exemplo)
+X, y = load_breast_cancer(return_X_y=True)
+model = RandomForestClassifier(max_depth=20, random_state=42)
+model.fit(X, y)  # O modelo deve estar treinado
+
+# 2. Inicializar e avaliar com ai-critic
+critic = AICritic(model, X, y)
+report = critic.evaluate()
+
+# A visualização padrão é 'all' (todas as camadas)
+print(report)
+```
+
+## 🧩 Saída Multi-Camadas
+
+O `ai-critic` nunca despeja tudo de uma vez. Ele estrutura os resultados em camadas de decisão claras.
+
+### 🔹 Visualização Executiva (`view="executive"`)
+
+Projetado para CTOs, gerentes e *stakeholders*. Sem jargão de ML.
+
+```python
+critic.evaluate(view="executive")
+```
+
+**Exemplo de Saída:**
+
+```json
+{
+  "verdict": "❌ Não Confiável",
+  "risk_level": "high",
+  "deploy_recommended": false,
+  "main_reason": "Forte evidência de vazamento de dados inflando o desempenho do modelo."
+}
+```
+
+### 🔹 Visualização Técnica (`view="technical"`)
+
+Projetado para engenheiros de ML. Acionável, diagnóstico e focado no que precisa ser corrigido.
+
+```python
+critic.evaluate(view="technical")
+```
+
+**Exemplo de Saída:**
+
+```json
+{
+  "key_risks": [
+    "Vazamento de dados suspeito devido à correlação quase perfeita entre recurso e alvo.",
+    "Pontuação de validação cruzada perfeita detectada (estatisticamente improvável).",
+    "A profundidade da árvore pode ser muito alta para o tamanho do conjunto de dados."
+  ],
+  "model_health": {
+    "data_leakage": true,
+    "suspicious_cv": true,
+    "structural_risk": true,
+    "robustness_verdict": "misleading"
+  },
+  "recommendations": [
+    "Auditar e remover recursos com vazamento.",
+    "Reduzir a complexidade do modelo.",
+    "Executar novamente a validação após a mitigação do vazamento."
+  ]
+}
+```
+
+### 🔹 Visualização Detalhada (`view="details"`)
+
+Projetado para auditoria, depuração e conformidade.
+
+```python
+critic.evaluate(view="details")
+```
+
+Inclui:
+
+*   Métricas brutas
+*   Correlações de recursos
+*   Pontuações de robustez
+*   Avisos estruturais
+*   Rastreabilidade completa
+
+### 🔹 Visualização Combinada (`view="all"`)
+
+Retorna todas as três camadas em um único dicionário.
+
+```python
+critic.evaluate(view="all")
+```
+
+**Retorna:**
+
+```json
+{
+  "executive": {...},
+  "technical": {...},
+  "details": {...}
+}
+```
+
+## ⚙️ API Principal
+
+### `AICritic`
+
+| Parâmetro | Descrição |
+| :--- | :--- |
+| `model` | Modelo `scikit-learn` treinado |
+| `X` | Matriz de recursos |
+| `y` | Vetor alvo |
+
+**Uso:** `AICritic(model, X, y)`
+
+### `evaluate()`
+
+| Parâmetro | Descrição |
+| :--- | :--- |
+| `view` | Camada de saída desejada: `"executive"`, `"technical"`, `"details"`, ou `"all"` (padrão) |
+
+**Uso:** `evaluate(view="all")`
+
+## 🧠 O que o ai-critic Detecta
+
+| Categoria | Riscos Detectados |
+| :--- | :--- |
+| **🔍 Riscos de Dados** | Vazamento de alvo via correlação, NaNs, desequilíbrio de classes |
+| **🧱 Riscos Estruturais** | Árvores excessivamente complexas, altas taxas de recurso/amostra, *configuration smells* |
+| **📈 Riscos de Validação** | Pontuações de CV suspeitosamente perfeitas, variância irreal |
+| **🧪 Riscos de Robustez** | Sensibilidade a ruído, robustez enganosa se a linha de base estiver inflada |
+
+## 🧪 Exemplo: Detectando Vazamento de Dados
+
+```python
+import numpy as np
+# ... (imports e código do modelo)
+
+# Vazamento artificial: adicionando o alvo como um recurso
+X_leaky = np.hstack([X, y.reshape(-1, 1)])
+
+critic = AICritic(model, X_leaky, y)
+executive_report = critic.evaluate(view="executive")
+
+print(executive_report)
+```
+
+**Saída (Visualização Executiva):**
+
+```
+❌ Não Confiável
+Forte evidência de vazamento de dados inflando o desempenho do modelo.
+```
+
+## 🛡️ Melhores Práticas
+
+*   Execute o `ai-critic` antes da implantação.
+*   Nunca confie cegamente em pontuações de CV perfeitas.
+*   Use a Visualização Executiva em seu *pipeline* de CI/CD como um portão de modelo.
+*   Use a Visualização Técnica durante a iteração do modelo.
+*   Use a Visualização Detalhada para auditoria e conformidade.
+
+## 🧭 Casos de Uso Típicos
+
+*   Auditorias de modelo pré-implantação
+*   Governança e conformidade de ML
+*   Portões de modelo CI/CD
+*   Ensino de ceticismo em ML
+*   Explicação de risco de ML para *stakeholders* não técnicos
+
+## 📄 Licença
+
+Distribuído sob a Licença MIT.
+
+## 🧠 Nota Final
+
+O `ai-critic` não é uma ferramenta de *benchmarking*. É uma **ferramenta de decisão**.
+
+Se um modelo falhar aqui, não significa que seja ruim — significa que **não deve ser confiável ainda**.

ai_critic-0.2.1.dist-info/RECORD

@@ -0,0 +1,12 @@
+ai_critic/__init__.py,sha256=H6DlPMmbcFUamhsNULPLk9vHx81XCiXuKKf63EJ8eM0,53
+ai_critic/critic.py,sha256=4fKwR7LtXGlQihstZWqauBZT2BmbaSLpuO9FBV42tus,2287
+ai_critic/evaluators/__init__.py,sha256=Jmmz9899YD__4Uj3bA6R7vYOwlH2giPc1wuCSLv7FVw,170
+ai_critic/evaluators/config.py,sha256=gBXaS8Qxl14f40JnvMWgA0Z0SGEtbCuCHpTOPem0H90,1163
+ai_critic/evaluators/data.py,sha256=YAK5NkwCeJOny_UueZ5ALwvEcRDIbEck404eV2oqWnc,1871
+ai_critic/evaluators/performance.py,sha256=JpXM_7-RN_q_FvXga4TkSVBBo90Nk0AdBWbjmS-D1oI,1469
+ai_critic/evaluators/robustness.py,sha256=UiGTpE-h2d2U19p1Ce4XpcMv4NMb2I4MmrlTrsPTIag,1808
+ai_critic/evaluators/summary.py,sha256=drP43HrWu1WJfLiUIQVczJ5Qs8sfoywpXFdavd2ogQI,3516
+ai_critic-0.2.1.dist-info/METADATA,sha256=TFYwZAG1AvWnvVweQpBS3p9obX11h_M_CNVFgzt6MLs,7064
+ai_critic-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ai_critic-0.2.1.dist-info/top_level.txt,sha256=TRyZkm1vyLLcFDg_80yeg5cHvPis_oW1Ti170417jkw,10
+ai_critic-0.2.1.dist-info/RECORD,,

ai_critic-0.1.0.dist-info/METADATA

@@ -1,64 +0,0 @@
-Metadata-Version: 2.4
-Name: ai-critic
-Version: 0.1.0
-Summary: Fast AI evaluator for scikit-learn models
-Author-email: Luiz Seabra <seu-email@exemplo.com>
-Requires-Python: >=3.9
-Description-Content-Type: text/markdown
-Requires-Dist: numpy
-Requires-Dist: scikit-learn
-
-# AI Critic 🧠⚖️
-
-**AI Critic** is a fast evaluator for scikit-learn models.
-It analyzes configuration, robustness, data quality and performance in minutes.
-
-## Install
-
-```bash
-pip install ai-critic
-```
-
-## Quick Example
-
-```python
-from sklearn.datasets import load_breast_cancer
-from sklearn.ensemble import RandomForestClassifier
-from ai_critic import AICritic
-
-X, y = load_breast_cancer(return_X_y=True)
-
-model = RandomForestClassifier(n_estimators=50, max_depth=3)
-
-critic = AICritic(model, X, y)
-report = critic.evaluate()
-
-print(report)
-```
-
-## What it evaluates
-
-*   Model configuration sanity
-*   Data consistency
-*   Robustness to noise
-*   Basic performance metrics
-
-## Philosophy
-
-Fast, modular, and brutally honest AI evaluation.
-
-📌 README simples = mais confiança
-
----
-
-## Development & Testing
-
-To test the package locally as an end-user (mandatory for development):
-
-In the root directory:
-
-```bash
-pip install -e .
-python -c "from ai_critic import AICritic; print('OK')"
-python -m pytest
-```

ai_critic-0.1.0.dist-info/RECORD

@@ -1,11 +0,0 @@
-ai_critic/__init__.py,sha256=H6DlPMmbcFUamhsNULPLk9vHx81XCiXuKKf63EJ8eM0,53
-ai_critic/critic.py,sha256=ulkj6A6flREQy4HMdFj8ktp-iH_-5bsGkxsYE6zCMBE,635
-ai_critic/evaluators/__init__.py,sha256=Jmmz9899YD__4Uj3bA6R7vYOwlH2giPc1wuCSLv7FVw,170
-ai_critic/evaluators/config.py,sha256=3q4_Wg-lbrM_I_tcZl4InL0_OijlHNtnDBnewaGDtco,195
-ai_critic/evaluators/data.py,sha256=gbDz1NdJ3vZuXRGV3mQtpfLgmVRnowfCTCJ0RH5SlxM,359
-ai_critic/evaluators/performance.py,sha256=25Ja6jOaSc-maSVJNABrhGrxElYQH7IDGGbYx_Rr0J8,257
-ai_critic/evaluators/robustness.py,sha256=InBx3bmTTGBU8yQ4I-E81xOC2gEAOpwpKRSqkxn2Cw4,435
-ai_critic-0.1.0.dist-info/METADATA,sha256=iO4Oz0mSHsm0YzpeEzmwzAwJaNvY2hzb2dfn4RbBSaE,1286
-ai_critic-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ai_critic-0.1.0.dist-info/top_level.txt,sha256=TRyZkm1vyLLcFDg_80yeg5cHvPis_oW1Ti170417jkw,10
-ai_critic-0.1.0.dist-info/RECORD,,