aba new backend api

aba/main_test.py

@@ -64,7 +64,7 @@ def main():
     print("=" * 50)
 
     # Build framework from the given input specification file
-    aba_framework = build_aba_framework("aba\examples\exemple.txt")
+    aba_framework = build_aba_framework("aba/examples/exemple.txt")
     print(f"\n ------- Original ABA framework -------\n{aba_framework}")
 
     base_framework = deepcopy(aba_framework)

aba/models.py

@@ -0,0 +1,69 @@
+from pydantic import BaseModel
+from typing import List, Optional, Dict, Tuple, Any
+
+
+# === Basic DTOs ===
+
+class RuleDTO(BaseModel):
+    """Represents a single inference rule in the ABA framework."""
+    id: str
+    head: str
+    body: List[str]
+
+
+class FrameworkSnapshot(BaseModel):
+    """Snapshot of an ABA framework at a specific stage (original or transformed)."""
+    language: List[str]
+    assumptions: List[str]
+    rules: List[RuleDTO]
+    contraries: List[Tuple[str, str]]
+    preferences: Optional[Dict[str, List[str]]] = None
+
+
+# === Transformation tracking ===
+
+class TransformationStep(BaseModel):
+    """Represents one transformation step (non-circular, atomic, etc.)."""
+    step: str  # 'non_circular' | 'atomic' | 'none'
+    applied: bool
+    reason: Optional[str] = None
+    description: Optional[str] = None
+    result_snapshot: Optional[FrameworkSnapshot] = None
+
+
+# === ABA+ details ===
+
+class ABAPlusDTO(BaseModel):
+    """Results specific to ABA+ semantics (extended attacks between assumption sets)."""
+    assumption_combinations: List[str]
+    normal_attacks: List[str]
+    reverse_attacks: List[str]
+
+
+# === Meta info ===
+
+class MetaInfo(BaseModel):
+    """Metadata about the ABA computation process."""
+    request_id: str
+    timestamp: str
+    transformed: bool
+    transformations_applied: List[str]
+    warnings: Optional[List[str]] = []
+    errors: Optional[List[str]] = []
+
+
+# === Full API response ===
+
+class ABAApiResponseModel(BaseModel):
+    """
+    Represents the full backend response for an ABA/ABA+ computation request.
+    Includes both the original and transformed frameworks, all transformation steps,
+    and computed results (arguments, attacks, ABA+ extensions).
+    """
+    meta: MetaInfo
+    original_framework: FrameworkSnapshot
+    transformations: List[TransformationStep]
+    final_framework: FrameworkSnapshot
+    arguments: List[str]
+    attacks: List[str]
+    aba_plus: ABAPlusDTO

app.py

@@ -1,28 +1,69 @@
+import io
+import json
+import asyncio
+from pathlib import Path
+import pandas as pd
+import torch
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from relations.predict_bert import predict_relation
+from aba.aba_builder import prepare_aba_plus_framework, build_aba_framework_from_text
+from aba.models import (
+    RuleDTO,
+    FrameworkSnapshot,
+    TransformationStep,
+    ABAApiResponseModel,
+    ABAPlusDTO,
+    MetaInfo,
+)
+from gradual.computations import compute_gradual_space
+from gradual.models import GradualInput, GradualOutput
 import os
+from copy import deepcopy
+from datetime import datetime
 
 cache_dir = "/tmp/hf_cache"
 os.environ["TRANSFORMERS_CACHE"] = cache_dir
 os.makedirs(cache_dir, exist_ok=True)
 
-from gradual.models import GradualInput, GradualOutput
-# from gradual.computations import compute_gradual_semantics
-from gradual.computations import compute_gradual_space
-from aba.aba_builder import prepare_aba_plus_framework, build_aba_framework_from_text
-from relations.predict_bert import predict_relation
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-from fastapi.responses import FileResponse, StreamingResponse, JSONResponse
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi import FastAPI, UploadFile, File, Form, HTTPException
-import torch
-import pandas as pd
-from pathlib import Path
-import asyncio
-import json
-import io
+
+def _make_snapshot(fw) -> FrameworkSnapshot:
+    return FrameworkSnapshot(
+        language=[str(l) for l in sorted(fw.language, key=str)],
+        assumptions=[str(a) for a in sorted(fw.assumptions, key=str)],
+        rules=[
+            RuleDTO(
+                id=r.rule_name,
+                head=str(r.head),
+                body=[str(b) for b in sorted(r.body, key=str)],
+            )
+            for r in sorted(fw.rules, key=lambda r: r.rule_name)
+        ],
+        contraries=[
+            (str(c.contraried_literal), str(c.contrary_attacker))
+            for c in sorted(fw.contraries, key=str)
+        ],
+        preferences={
+            str(k): [str(v) for v in sorted(vals, key=str)]
+            for k, vals in (fw.preferences or {}).items()
+        } if getattr(fw, "preferences", None) else None,
+    )
 
 
+def _format_set(s) -> str:
+    # s may be a Python set/frozenset of Literal or strings.
+    try:
+        items = sorted([str(x) for x in s], key=str)
+    except Exception:
+        # fallback if s is already a string like "{a,b}"
+        return str(s)
+    return "{" + ",".join(items) + "}"
+
 # -------------------- Config -------------------- #
 
+
 ABA_EXAMPLES_DIR = Path("./aba/examples")
 SAMPLES_DIR = Path("./relations/examples/samples")
 GRADUAL_EXAMPLES_DIR = Path("./gradual/examples")
@@ -112,37 +153,225 @@ def get_sample(filename: str):
 
 @app.post("/aba-upload")
 async def aba_upload(file: UploadFile = File(...)):
+    """
+    Handle classical ABA generation.
+    Returns:
+        - original_framework: before transformations
+        - final_framework: after transformations
+        - transformations: steps applied (non-circular / atomic)
+        - arguments, attacks
+        - empty aba_plus section
+    """
     content = await file.read()
     text = content.decode("utf-8")
 
-    aba_framework = build_aba_framework_from_text(text)
-    aba_framework.generate_arguments()
-    aba_framework.generate_attacks()
+    # === 1. Build original ABA framework ===
+    base_framework = build_aba_framework_from_text(text)
+    original_snapshot = _make_snapshot(base_framework)
+
+    # === 2. Transform the framework ===
+    copy_framework = deepcopy(base_framework)
+    transformed_framework = copy_framework.transform_aba()
+
+    was_circular = base_framework.is_aba_circular()
+    was_atomic = base_framework.is_aba_atomic()
+
+    transformed_framework = deepcopy(base_framework).transform_aba()
+
+    # Detect transformation type
+    transformations: list[TransformationStep] = []
+    if transformed_framework.language != base_framework.language or transformed_framework.rules != base_framework.rules:
+        # Some transformation happened
+        if was_circular:
+            transformations.append(
+                TransformationStep(
+                    step="non_circular",
+                    applied=True,
+                    reason="The framework contained circular dependencies.",
+                    description="Transformed into a non-circular version.",
+                    result_snapshot=_make_snapshot(transformed_framework),
+                )
+            )
+        elif not was_atomic:
+            transformations.append(
+                TransformationStep(
+                    step="atomic",
+                    applied=True,
+                    reason="The framework contained rules with non-assumption bodies.",
+                    description="Transformed into an atomic version.",
+                    result_snapshot=_make_snapshot(transformed_framework),
+                )
+            )
+    else:
+        # No transformation
+        transformations.append(
+            TransformationStep(
+                step="none",
+                applied=False,
+                reason="The framework was already non-circular and atomic.",
+                description="No transformation applied.",
+                result_snapshot=None,
+            )
+        )
+
+    # === 3. Generate arguments and attacks on transformed ===
+    transformed_framework.generate_arguments()
+    transformed_framework.generate_attacks()
+
+    final_snapshot = _make_snapshot(transformed_framework)
+
+    # === 4. Build response model ===
+    response = ABAApiResponseModel(
+        meta=MetaInfo(
+            request_id=f"req-{datetime.utcnow().timestamp()}",
+            timestamp=datetime.utcnow().isoformat(),
+            transformed=any(t.applied for t in transformations),
+            transformations_applied=[
+                t.step for t in transformations if t.applied
+            ],
+            warnings=[],
+            errors=[],
+        ),
+        original_framework=original_snapshot,
+        transformations=transformations,
+        final_framework=final_snapshot,
+        arguments=[str(arg) for arg in sorted(
+            transformed_framework.arguments, key=str)],
+        attacks=[str(att)
+                 for att in sorted(transformed_framework.attacks, key=str)],
+        aba_plus=ABAPlusDTO(
+            assumption_combinations=[],
+            normal_attacks=[],
+            reverse_attacks=[],
+        ),
+    )
 
-    results = {
-        "assumptions": [str(a) for a in aba_framework.assumptions],
-        "arguments": [str(arg) for arg in aba_framework.arguments],
-        "attacks": [str(att) for att in aba_framework.attacks],
-    }
-    return results
+    return response
 
 
-@app.post("/aba-plus-upload")
-async def aba_upload(file: UploadFile = File(...)):
+@app.post("/aba-plus-upload", response_model=ABAApiResponseModel)
+async def aba_plus_upload(file: UploadFile = File(...)):
+    """
+    Handle ABA+ generation.
+    Returns:
+      - original_framework / final_framework with snapshots
+      - transformations applied (non_circular / atomic)
+      - arguments, classical attacks (from transformed framework)
+      - aba_plus: assumption_combinations, normal_attacks, reverse_attacks (string lists)
+    """
     content = await file.read()
     text = content.decode("utf-8")
 
-    aba_framework = build_aba_framework_from_text(text)
-    aba_framework = prepare_aba_plus_framework(aba_framework)
-    aba_framework.make_aba_plus()
+    # 1) Build base framework + original snapshot
+    base_fw = build_aba_framework_from_text(text)
+    original_snapshot = _make_snapshot(base_fw)
+
+    was_circular = base_fw.is_aba_circular()
+    was_atomic = base_fw.is_aba_atomic()
+
+    # 2) Transform (deepcopy → transform_aba)
+    transformed = deepcopy(base_fw).transform_aba()
+
+    # Track transformation step(s)
+    transformations: list[TransformationStep] = []
+    if transformed.language != base_fw.language or transformed.rules != base_fw.rules:
+        if was_circular:
+            transformations.append(
+                TransformationStep(
+                    step="non_circular",
+                    applied=True,
+                    reason="The framework contained circular dependencies.",
+                    description="Transformed into a non-circular version.",
+                    result_snapshot=_make_snapshot(transformed),
+                )
+            )
+        elif not was_atomic:
+            transformations.append(
+                TransformationStep(
+                    step="atomic",
+                    applied=True,
+                    reason="The framework contained non-atomic rules.",
+                    description="Transformed into an atomic version.",
+                    result_snapshot=_make_snapshot(transformed),
+                )
+            )
+    else:
+        transformations.append(
+            TransformationStep(
+                step="none",
+                applied=False,
+                reason="The framework was already non-circular and atomic.",
+                description="No transformation applied.",
+                result_snapshot=None,
+            )
+        )
+
+    # 3) Prepare for ABA+ (on the transformed copy) and compute
+    # generates arguments + classical attacks
+    fw_plus = prepare_aba_plus_framework(transformed)
+    fw_plus.make_aba_plus()  # fills assumption_combinations, normal_attacks, reverse_attacks
+
+    warnings = []
+    if fw_plus.preferences:
+        all_assumpptions = {str(a) for a in fw_plus.assumptions}
+        pref_keys = {str(k) for k in fw_plus.preferences.keys()}
+        if not pref_keys.issubset(all_assumpptions):
+            warnings.append(
+                "Incomplete preference relation detected: not all assumptions appear in the preference mapping."
+            )
+
+    # 4) Final snapshot
+    final_snapshot = _make_snapshot(fw_plus)
+
+    # 5) Serialize ABA+ pieces as strings
+    assumption_sets = sorted(
+        [_format_set(s)
+         for s in getattr(fw_plus, "assumption_combinations", [])],
+        key=lambda x: (len(x), x)
+    )
 
-    results = {
-        "assumptions": [str(a) for a in aba_framework.assumptions],
-        "arguments": [str(arg) for arg in aba_framework.arguments],
-        "attacks": [str(att) for att in aba_framework.attacks],
-        "reverse_attacks": [str(ratt) for ratt in aba_framework.reverse_attacks],
-    }
-    return results
+    normal_str = [
+        f"{_format_set(src)} → {_format_set(dst)}"
+        for (src, dst) in sorted(
+            getattr(fw_plus, "normal_attacks", []),
+            key=lambda p: (str(p[0]), str(p[1])),
+        )
+    ]
+
+    reverse_str = [
+        f"{_format_set(src)} → {_format_set(dst)}"
+        for (src, dst) in sorted(
+            getattr(fw_plus, "reverse_attacks", []),
+            key=lambda p: (str(p[0]), str(p[1])),
+        )
+    ]
+    # arguments/attacks from transformed framework (already prepared)
+    arguments = [str(arg) for arg in sorted(fw_plus.arguments, key=str)]
+    attacks = [str(att) for att in sorted(fw_plus.attacks, key=str)]
+
+    # 6) Build response
+    resp = ABAApiResponseModel(
+        meta=MetaInfo(
+            request_id=f"req-{datetime.utcnow().timestamp()}",
+            timestamp=datetime.utcnow().isoformat(),
+            transformed=any(t.applied for t in transformations),
+            transformations_applied=[
+                t.step for t in transformations if t.applied],
+            warnings=warnings,
+            errors=[],
+        ),
+        original_framework=original_snapshot,
+        transformations=transformations,
+        final_framework=final_snapshot,
+        arguments=arguments,
+        attacks=attacks,
+        aba_plus=ABAPlusDTO(
+            assumption_combinations=assumption_sets,
+            normal_attacks=normal_str,
+            reverse_attacks=reverse_str,
+        ),
+    )
+    return resp
 
 
 @app.get("/aba-examples")
@@ -161,16 +390,6 @@ def get_aba_example(filename: str):
 
 # --- Gradual semantics --- #
 
-# @app.post("/gradual", response_model=GradualOutput)
-# def compute_gradual(input_data: GradualInput):
-#     """API endpoint to compute Weighted h-Categorizer samples and convex hull."""
-#     return compute_gradual_semantics(
-#         A=input_data.A,
-#         R=input_data.R,
-#         n_samples=input_data.n_samples,
-#         max_iter=input_data.max_iter
-#     )
-
 @app.post("/gradual", response_model=GradualOutput)
 def compute_gradual(input_data: GradualInput):
     """