added deepcopies to fix normal attack generation

aba/aba_builder.py

@@ -11,10 +11,10 @@ import os
 def build_aba_framework(doc_path: str) -> ABAFramework:
     """
     Build an ABAFramework object from a structured document.
-    
+
     Args:
         doc_path (str): Path to the document to parse.
-    
+
     Returns:
         ABAFramework: An ABAFramework instance containing:
             - language (Set[Literal]): Set of Literal objects.
@@ -22,7 +22,7 @@ def build_aba_framework(doc_path: str) -> ABAFramework:
             - assumptions (Set[Literal]): Set of assumptions.
             - contraries (Set[Contrary]): Set of contraries.
             - preferences (Dict[Literal, Set[Literal]]): Preference mappings.
-    
+
     Example:
         >>> aba = build_aba_framework("./backend/doc.txt")
         >>> isinstance(next(iter(aba.language)), Literal)
@@ -33,20 +33,20 @@ def build_aba_framework(doc_path: str) -> ABAFramework:
     # Parse the document
     language_parse, assumptions_parse, contraries_parse, rules_parse, preferences_parse = parse_doc(
         doc_path)
-    
+
     # Initialize containers
     language: Dict[str, Literal] = {}
     rules: Set[Rule] = set()
     contraries: Set[Contrary] = set()
     assumptions: Set[Literal] = set()
     preferences: Dict[Literal, Set[Literal]] = {}
-    
+
     # Language: build Literal objects
     for lit in language_parse:
         language[lit] = Literal(lit)
-    
+
     language_set: Set[Literal] = set(language.values())
-    
+
     # Rules: convert parsed structure into Rule objects
     for rule in rules_parse:
         r_id = next(iter(rule))
@@ -54,29 +54,30 @@ def build_aba_framework(doc_path: str) -> ABAFramework:
         body_atoms = rule[r_id][head]
         body_literals = {language[i] for i in body_atoms if i in language}
         rules.add(Rule(r_id, language[head], body_literals))
-    
+
     # Contraries: build Contrary objects
     for lit1, lit2 in contraries_parse:
         contraries.add(Contrary(language[lit1], language[lit2]))
-    
+
     # Assumptions: convert to set of Literal
     for lit in assumptions_parse:
         assumptions.add(language[lit])
-    
+
     # Preferences: merge all preference dictionaries and convert to Literal objects
     for pref_dict in preferences_parse:
         for lit_str, less_preferred_strs in pref_dict.items():
             if lit_str in language:
                 lit_obj = language[lit_str]
                 # Convert string literals to Literal objects
-                less_preferred_objs = {language[lp] for lp in less_preferred_strs if lp in language}
-                
+                less_preferred_objs = {
+                    language[lp] for lp in less_preferred_strs if lp in language}
+
                 # Merge with existing preferences for this literal
                 if lit_obj in preferences:
                     preferences[lit_obj].update(less_preferred_objs)
                 else:
                     preferences[lit_obj] = less_preferred_objs
-    
+
     # Build ABA framework
     aba_framework = ABAFramework(
         language=language_set,
@@ -85,7 +86,7 @@ def build_aba_framework(doc_path: str) -> ABAFramework:
         contraries=contraries,
         preferences=preferences
     )
-    
+
     return aba_framework
 
 
@@ -93,26 +94,26 @@ def prepare_aba_plus_framework(aba_framework: ABAFramework) -> ABAFramework:
     """
     Prepare an ABA framework for ABA+ by ensuring it's atomic and generating
     all necessary components.
-    
+
     Args:
         aba_framework: The ABA framework to prepare
-        
+
     Returns:
         ABAFramework: The prepared framework (modified in place)
     """
-    
+
     # Generate arguments for atomic framework
     print("\nGenerating arguments for atomic framework...")
     aba_framework.arguments.clear()
     aba_framework.generate_arguments()
     print(f"Generated {len(aba_framework.arguments)} arguments")
-    
+
     # Generate standard attacks
     print("\nGenerating standard attacks for atomic framework...")
     aba_framework.attacks.clear()
     aba_framework.generate_attacks()
     print(f"Generated {len(aba_framework.attacks)} attacks\n")
-    
+
     return aba_framework
 
 
@@ -140,4 +141,4 @@ def build_aba_framework_from_text(text: str) -> ABAFramework:
         except OSError:
             pass
 
-    return aba
+    return aba

aba/aba_framework.py

@@ -10,6 +10,7 @@ Features:
 - Provides visualization of attack graphs using PyVis.
 """
 
+from copy import deepcopy
 from .argument import Argument
 from .contrary import Contrary
 from .literal import Literal
@@ -189,7 +190,7 @@ class ABAFramework:
 
     # ------------------------- ABA Methods -------------------------
 
-    def transform_aba(self) -> None:
+    def transform_aba(self) -> "ABAFramework":
         """
         Transforms the ABA framework to ensure it is both non-circular and atomic.
 
@@ -204,12 +205,15 @@ class ABAFramework:
         print("\n ------- Transforming ABA framework -------\n")
         if self.is_aba_circular():
             print("The ABA Framework is circular\n")
-            self.make_aba_not_circular()
+            return self.make_aba_not_circular()
         elif not self.is_aba_atomic():
             print("The ABA Framework is not atomic\n")
-            self.make_aba_atomic()
+            return self.make_aba_atomic()
+        else:
+            print("The ABA Framework is already non-circular and atomic\n")
+            return deepcopy(self)
 
-    def make_aba_atomic(self) -> None:
+    def make_aba_atomic(self) -> "ABAFramework":
         """
         Transforms the ABA framework into an atomic one.
 
@@ -236,6 +240,8 @@ class ABAFramework:
                 R = { a <- xd }
                 Contraries = { xd̄ = xnd, xnd̄ = x }
         """
+        new_framework = deepcopy(self)
+
         new_language = set(self.language)
         new_assumptions = set(self.assumptions)
         new_rules = set()
@@ -265,10 +271,16 @@ class ABAFramework:
             new_rules.add(Rule(rule.rule_name, rule.head, new_body))
 
         # Step 3: Update framework
-        self.language = new_language
-        self.assumptions = new_assumptions
-        self.rules = new_rules
-        self.contraries = new_contraries
+        # self.language = new_language
+        # self.assumptions = new_assumptions
+        # self.rules = new_rules
+        # self.contraries = new_contraries
+        new_framework.language = new_language
+        new_framework.assumptions = new_assumptions
+        new_framework.rules = new_rules
+        new_framework.contraries = new_contraries
+
+        return new_framework
 
     def is_aba_atomic(self) -> bool:
         """
@@ -335,7 +347,7 @@ class ABAFramework:
                     return True  # Cycle found
         return False  # No cycles
 
-    def make_aba_not_circular(self) -> None:
+    def make_aba_not_circular(self) -> "ABAFramework":
         """
         Transforms the ABA framework to a non-circular one by renaming heads and bodies of rules.
 
@@ -368,7 +380,7 @@ class ABAFramework:
                     x1 <- a  
                     x  <- a  
         """
-
+        new_copy = deepcopy(self)
         k = len(self.language) - len(self.assumptions)
         new_language = set(self.language)
         new_rules = set()
@@ -395,8 +407,12 @@ class ABAFramework:
                     new_rule_name = f"{rule.rule_name}_{i+1}"
                     new_rules.add(Rule(new_rule_name, new_head, new_body))
 
-        self.language = new_language
-        self.rules = new_rules
+                # self.language = new_language
+                # self.rules = new_rules
+        new_copy.language = new_language
+        new_copy.rules = new_rules
+
+        return new_copy
 
     # ------------------------- ABA+ Methods -------------------------
 

aba/parsing.py

@@ -1,6 +1,7 @@
 import re
 from typing import List, Tuple, Dict, Set
 
+
 def _parse_list(content: str) -> List[str]:
     """
     Parse a string representing a list of literals into a Python list of strings.
@@ -23,6 +24,7 @@ def _parse_list(content: str) -> List[str]:
         return []
     return [x.strip() for x in content.split(",") if x.strip()]
 
+
 def _parse_rule_line(line: str) -> Dict[str, Dict[str, Set[str]]]:
     """
     Parse a single rule line of the form [rX]: head <- body.
@@ -45,14 +47,15 @@ def _parse_rule_line(line: str) -> Dict[str, Dict[str, Set[str]]]:
         return {r_id: {head: body_atoms}}
     return {}
 
+
 def _parse_pref_line(line: str) -> Dict[str, Set[str]]:
     """
     Parse a preference line of the form:
     - PREF: a,b > c,d > e
     - PREF: a,b > c and a > d
-    
+
     Supports multiple chains joined by "and".
-    
+
     Returns:
         Dict[str, Set[str]]: Dictionary mapping each element to all elements
                              that come after it in the preference chain(s).
@@ -83,6 +86,7 @@ def _parse_pref_line(line: str) -> Dict[str, Set[str]]:
 
     return pref_dict
 
+
 def parse_doc(path: str) -> Tuple[
     List[str],
     List[str],
@@ -120,13 +124,13 @@ def parse_doc(path: str) -> Tuple[
     contraries: List[Tuple[str, str]] = []
     rules: List[Dict[str, Dict[str, Set[str]]]] = []
     preferences: List[Dict[str, Set[str]]] = []
-    
+
     with open(path, "r") as f:
         for line in f:
             line = line.strip()
             if not line:
                 continue
-            
+
             if line.startswith("L:"):
                 language = _parse_list(line.split(":", 1)[1])
             elif line.startswith("A:"):
@@ -143,12 +147,13 @@ def parse_doc(path: str) -> Tuple[
                 pref_dict = _parse_pref_line(line)
                 if pref_dict:
                     preferences.append(pref_dict)
-    
+
     return language, assumptions, contraries, rules, preferences
 
 
 if __name__ == "__main__":
-    language, assumptions, contraries, rules, preferences = parse_doc("./backend/data/simple_plus2AND.txt")
+    language, assumptions, contraries, rules, preferences = parse_doc(
+        "./backend/data/simple_plus2AND.txt")
     print("Language:", language)
     print("Assumptions:", assumptions)
     print("Contraries:", contraries)

aba/test.py

@@ -0,0 +1,78 @@
+"""
+Main entry point for generating and analyzing an ABA+ framework.
+
+This script:
+  1. Builds an ABA framework from a text specification.
+  2. Prints the original (classical) ABA framework.
+  3. Prepares the framework for ABA+ (atomic transformation + argument/attack generation).
+  4. Generates ABA+ components (assumption combinations, normal/reverse attacks).
+  5. Prints the resulting ABA+ framework components.
+  6. Plots the ABA+ attack graph between sets of assumptions.
+"""
+
+from copy import deepcopy
+from aba.aba_builder import build_aba_framework, prepare_aba_plus_framework
+from aba.aba_utils import print_aba_plus_results
+from aba.aba_framework import ABAFramework
+
+
+def testABA(aba_framework: ABAFramework):
+
+    copy_framework = deepcopy(aba_framework)
+
+    transformed_framework: ABAFramework = copy_framework.transform_aba()
+    print("\n ------- Transformed ABA framework -------\n ")
+    print(transformed_framework)
+
+    # Generate arguments
+    transformed_framework.generate_arguments()
+    gen_args = transformed_framework.arguments
+    print("\n ------- Generated arguments -------\n ")
+    print(gen_args)
+
+    # Generate attacks
+    transformed_framework.generate_attacks()
+    attacks = transformed_framework.attacks
+    print("\n ------- Generated attacks -------\n ")
+    print(attacks, "\n")
+
+
+def testABAPlus(aba_framework: ABAFramework):
+
+    # === Step 2: Prepare the framework for ABA+ ===
+
+    aba_framework: ABAFramework = prepare_aba_plus_framework(aba_framework)
+
+    # === Step 3: Generate ABA+ components ===
+    print("\n" + "=" * 50)
+    print("Generating ABA+ Components")
+    print("=" * 50)
+    aba_framework.make_aba_plus()
+
+    # === Step 4: Print ABA+ results ===
+    print_aba_plus_results(aba_framework)
+    return aba_framework
+
+
+def main():
+    """
+    Main function to generate and analyze an ABA+ framework.
+    """
+    # === Step 1: Build the ABA framework from input file ===
+    print("\n" + "=" * 50)
+    print("Building ABA+ Framework")
+    print("=" * 50)
+
+    # Build framework from the given input specification file
+    aba_framework = build_aba_framework("aba\exemples\exemple.txt")
+    print(f"\n ------- Original ABA framework -------\n{aba_framework}")
+
+    base_framework = deepcopy(aba_framework)
+    testABA(base_framework)
+
+    aba_for_plus = deepcopy(aba_framework)
+    testABAPlus(aba_for_plus)
+
+
+if __name__ == "__main__":
+    main()