exactor-accelerator 2.0.0__py3-none-any.whl

exactor_accelerator/__init__.py

@@ -0,0 +1,56 @@
+"""
+Exactor Accelerator: High-Speed Boolean Logic Layer for TypeSafe AI
+
+Combines EXACTOR boolean minimization (Rust) with Jev (TypeSafe AI)
+to accelerate decisions by 4,770-24,000x with 95-100% accuracy.
+"""
+
+__version__ = "2.0.0"
+__author__ = "Exactor Contributors"
+__license__ = "MIT"
+
+from .config import configure, get_config
+from .ingestion import AdaptiveBinarizer, DataLoader, Proposition, BinarizationResult, SemanticPropositionDiscovery
+from .core import ExactorBridge, ExactorHypercubeReducer, ExactorSimplificationResult
+from .adapter import ExactorToJevTranslator, JevPayload, NoulQuestion, ChoiceQuestion, ScoreQuestion
+from .ledger import MemoryLedger
+from .engine import JevClient, HybridRuntime, QueryResult
+from .sklearn_interface import ExactorAcceleratorClassifier, ExactorAcceleratorMultiLabelClassifier
+from .model_persistence import save_model, load_model, log_to_mlflow, log_to_wandb
+from .sdk import ExactorAccelerator
+
+
+__all__ = [
+    # Top-level API
+    "configure",
+    "get_config",
+    "ExactorAccelerator",
+    "ExactorAcceleratorClassifier",
+    "ExactorAcceleratorMultiLabelClassifier",
+    # Model persistence
+    "save_model",
+    "load_model",
+    "log_to_mlflow",
+    "log_to_wandb",
+    # Ingestion
+    "SemanticPropositionDiscovery",
+    "AdaptiveBinarizer",
+    "DataLoader",
+    "Proposition",
+    "BinarizationResult",
+    # Core
+    "ExactorBridge",
+    "ExactorHypercubeReducer",
+    "ExactorSimplificationResult",
+    # Adapter
+    "ExactorToJevTranslator",
+    "JevPayload",
+    "NoulQuestion",
+    "ChoiceQuestion",
+    "ScoreQuestion",
+    # Ledger & Engine
+    "MemoryLedger",
+    "JevClient",
+    "HybridRuntime",
+    "QueryResult",
+]

exactor_accelerator/adapter/__init__.py

@@ -0,0 +1,10 @@
+from .jev_schema import NoulQuestion, ChoiceQuestion, ScoreQuestion, JevPayload
+from .translator import ExactorToJevTranslator
+
+__all__ = [
+    "NoulQuestion",
+    "ChoiceQuestion",
+    "ScoreQuestion",
+    "JevPayload",
+    "ExactorToJevTranslator",
+]

exactor_accelerator/adapter/jev_schema.py

@@ -0,0 +1,106 @@
+"""
+TypeSafe AI Jev Schema Primitives & Payload Models.
+Defines Noul, Choice, Score question types and the System One payload structure.
+"""
+
+from typing import Dict, Any, Optional, Union, List
+import json
+
+
+class NoulQuestion:
+    """
+    Noul question primitive (Bernoulli binary decision).
+    Returns a calibrated probability (0 to 1) representing the likelihood of truth.
+    """
+
+    def __init__(self, instructions: str):
+        self.type = "noul"
+        self.instructions = instructions
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.type,
+            "instructions": self.instructions,
+        }
+
+
+class ChoiceQuestion:
+    """
+    Choice question primitive for categorical decision-making.
+    Returns probabilities across each predefined option and the chosen category.
+    """
+
+    def __init__(self, instructions: str, criteria: Dict[str, Optional[str]]):
+        self.type = "choice"
+        self.instructions = instructions
+        self.criteria = criteria
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.type,
+            "instructions": self.instructions,
+            "criteria": self.criteria,
+        }
+
+
+class ScoreQuestion:
+    """
+    Score question primitive for continuous calibrated assessment on a spectrum.
+    TypeSafe API requires criteria to be an ordered list of score levels.
+    """
+
+    def __init__(self, instructions: str, criteria: Optional[Union[List[str], Dict[str, Optional[str]]]] = None):
+        self.type = "score"
+        self.instructions = instructions
+        if isinstance(criteria, dict):
+            self.criteria = [f"{k}: {v}" if v else k for k, v in criteria.items()]
+        elif isinstance(criteria, list):
+            self.criteria = criteria
+        else:
+            self.criteria = [
+                "Bajo: Bajo o nulo impacto/riesgo",
+                "Medio: Impacto moderado que requiere precaución",
+                "Crítico: Severo o crítico, activación mandatoria",
+            ]
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "type": self.type,
+            "instructions": self.instructions,
+            "criteria": self.criteria,
+        }
+
+
+class JevPayload:
+    """
+    Official payload structure for TypeSafe AI Jev System One model.
+    """
+
+    def __init__(
+        self,
+        state: Dict[str, Any],
+        questions: Dict[str, Union[NoulQuestion, ChoiceQuestion, ScoreQuestion, Dict[str, Any]]],
+        model: str = "jev-latest",
+    ):
+        self.model = model
+        self.state = state
+        self.questions = questions
+
+    def to_dict(self) -> Dict[str, Any]:
+        serialized_questions = {}
+        for q_name, q_obj in self.questions.items():
+            if hasattr(q_obj, "to_dict"):
+                serialized_questions[q_name] = q_obj.to_dict()
+            elif isinstance(q_obj, dict):
+                serialized_questions[q_name] = q_obj
+            else:
+                serialized_questions[q_name] = {"type": "noul", "instructions": str(q_obj)}
+
+        return {
+            "model": self.model,
+            "state": self.state,
+            "questions": serialized_questions,
+        }
+
+    def to_json(self, indent: int = 2) -> str:
+        return json.dumps(self.to_dict(), indent=indent, ensure_ascii=False)

exactor_accelerator/adapter/translator.py

@@ -0,0 +1,170 @@
+"""
+Dynamic Adapter: EXACTOR -> Jev.
+Translates Boolean formulas and hypercube terms from Exactor into typed questions
+for TypeSafe AI Jev (Noul, Choice, Score).
+"""
+
+from typing import Dict, Any, List, Optional
+from ..core.hypercube import ExactorSimplificationResult
+from ..ingestion.binarizer import Proposition
+from .jev_schema import NoulQuestion, ChoiceQuestion, ScoreQuestion, JevPayload
+
+
+class ExactorToJevTranslator:
+    """
+    Translates minimized Boolean logic formulas into calibrated question schemas for Jev.
+    """
+
+    def __init__(self, target_label: str = "evento_critico"):
+        self.target_label = target_label
+
+    def generate_human_explanation(
+        self,
+        result: ExactorSimplificationResult,
+        propositions_map: Optional[Dict[str, Proposition]] = None,
+    ) -> str:
+        """Converts mathematical Boolean terms into natural semantic explanation."""
+        if not result.terms:
+            return "Ninguna condición histórica de activación fue detectada."
+
+        clauses = []
+        for term in result.terms:
+            literals = []
+            for i, s in enumerate(term.states):
+                if s == 2:
+                    continue
+                v_name = result.variables[i]
+                prop = propositions_map.get(v_name) if propositions_map else None
+                desc = prop.description if prop else v_name
+                if s == 1:
+                    literals.append(f"[{desc}]")
+                elif s == 0:
+                    literals.append(f"[NO {desc}]")
+
+            clause_str = " Y ".join(literals) if literals else "SIEMPRE_ACTIVO"
+            clauses.append(clause_str)
+
+        if len(clauses) == 1:
+            return f"Se cumple cuando: {clauses[0]}"
+        return "Se cumple cuando al menos una de las siguientes combinaciones es verdadera: " + " O BIEN ".join(
+            [f"({c})" for c in clauses]
+        )
+
+    def create_questions_schema(
+        self,
+        result: ExactorSimplificationResult,
+        propositions_map: Optional[Dict[str, Proposition]] = None,
+        custom_action_choices: Optional[Dict[str, Optional[str]]] = None,
+    ) -> Dict[str, Any]:
+        """
+        Builds the complete typed questions schema according to TypeSafe AI specifications.
+        """
+        explanation = self.generate_human_explanation(result, propositions_map)
+        formula_snippet = result.formula_expr[:180] + ("..." if len(result.formula_expr) > 180 else "")
+
+        # 1. Primary Noul question: Exact boolean condition derived from Exactor
+        noul_instructions = (
+            f"¿Se cumple la condición booleana derivada del análisis histórico? "
+            f"Fórmula lógica: {formula_snippet}. Criterio: {explanation}"
+        )
+        criterio_logico = NoulQuestion(instructions=noul_instructions)
+
+        # 2. Autonomous Business Action: Choice question
+        if not custom_action_choices:
+            tl = self.target_label.lower()
+            if "fraud" in tl:
+                custom_action_choices = {
+                    "BLOQUEAR_TRANSACCION": "Si el riesgo de fraude o anomalía es alto y cumple las condiciones de riesgo",
+                    "REVISION_MANUAL": "Si hay sospecha moderada o parámetros limítrofes que requieren revisión",
+                    "APROBAR_TRANSACCION": "Si la transacción es legítima, habitual y de bajo riesgo",
+                }
+            elif "mitigation" in tl or "sre" in tl:
+                custom_action_choices = {
+                    "ACTIVAR_MITIGACION": "Si los incidentes y métricas de error superan los límites de SLA",
+                    "ESCALAR_A_GUARDIA": "Si hay degradación parcial del servicio",
+                    "DESESTIMAR_ALERTA": "Si las métricas están en parámetros normales de operación",
+                }
+            elif "churn" in tl:
+                custom_action_choices = {
+                    "OFERTA_RETENCION_INMEDIATA": "Si el cliente tiene alto riesgo de cancelación inminente",
+                    "CONTACTO_EXECUTIVE_CSM": "Si hay riesgo moderado de insatisfacción",
+                    "MANTENER_PLAN_ACTUAL": "Si el cliente está fidelizado y satisfecho",
+                }
+            elif "block" in tl or "soc" in tl or "ip" in tl:
+                custom_action_choices = {
+                    "BLOQUEAR_IP_FIREWALL": "Si se detecta un patrón claro de ciberataque o fuerza bruta",
+                    "AISLAR_HOST_EN_QUARANTINE": "Si hay anomalías de tráfico sospechosas",
+                    "PERMITIR_TRAFICO": "Si es tráfico verificado y legítimo",
+                }
+            elif "icu" in tl or "triage" in tl:
+                custom_action_choices = {
+                    "TRANSFERIR_A_UCI_URGENTE": "Si los signos vitales indican riesgo vital inminente",
+                    "OBSERVACION_CONTINUA_BOX": "Si el paciente requiere monitoreo intermedio",
+                    "ALTA_A_SALA_COMUN": "Si los parámetros del paciente están estables",
+                }
+            elif "escalate" in tl or "sup" in tl:
+                custom_action_choices = {
+                    "ESCALAR_A_SUPERVISOR_HUMANO": "Si el usuario está insatisfecho o reporta problemas críticos",
+                    "TRANSFERIR_A_AGENTE_SENIOR": "Si la consulta es compleja",
+                    "RESOLVER_CON_BOT": "Si es una consulta informativa estándar",
+                }
+            else:
+                custom_action_choices = {
+                    "APROBAR_OPERACION": "El evento cumple con todos los parámetros normales y no presenta riesgo",
+                    "REVISION_MANUAL": "Existe incertidumbre o valores límite en los parámetros del evento",
+                    "BLOQUEAR_RIESGO": "El evento cumple las condiciones lógicas de riesgo o anomalía",
+                }
+
+        business_action = ChoiceQuestion(
+            instructions=(
+                f"¿Qué acción de negocio debe ejecutarse sobre este evento considerando la regla lógica '{formula_snippet}'?"
+            ),
+            criteria=custom_action_choices,
+        )
+
+        # 3. Calibrated Risk/Severity Score question
+        score_question = ScoreQuestion(
+            instructions=f"Evalúa en una escala continua el nivel de impacto/criticidad del evento según la regla lógica.",
+            criteria={
+                "bajo": "Evento estándar sin activación de reglas críticas",
+                "medio": "Parámetros cercanos a los límites de activación lógica",
+                "critico": "Cumplimiento total de la regla booleana con alta severidad",
+            },
+        )
+
+        return {
+            "criterio_logico": criterio_logico,
+            "accion_recomendada": business_action,
+            "calibracion_criticidad": score_question,
+        }
+
+    def build_payload(
+        self,
+        raw_event_state: Dict[str, Any],
+        result: ExactorSimplificationResult,
+        propositions_map: Optional[Dict[str, Proposition]] = None,
+        custom_action_choices: Optional[Dict[str, Optional[str]]] = None,
+        include_all_questions: bool = True,
+    ) -> JevPayload:
+        """
+        Builds the exact JSON payload expected by the TypeSafe AI Jev API.
+        """
+        if include_all_questions:
+            questions = self.create_questions_schema(
+                result=result,
+                propositions_map=propositions_map,
+                custom_action_choices=custom_action_choices,
+            )
+        else:
+            explanation = self.generate_human_explanation(result, propositions_map)
+            questions = {
+                "criterio_logico": NoulQuestion(
+                    instructions=f"¿Se cumple la condición booleana derivada del análisis histórico? {explanation}"
+                )
+            }
+
+        return JevPayload(
+            model="jev-latest",
+            state={"evento": raw_event_state},
+            questions=questions,
+        )

exactor_accelerator/api/__init__.py

@@ -0,0 +1,3 @@
+from .server import app
+
+__all__ = ["app"]