tricc-oo 1.6.25__py3-none-any.whl → 1.6.27__py3-none-any.whl

tests/build.py

@@ -158,7 +158,7 @@ if __name__ == "__main__":
     if debug_level is not None:
         setup_logger("default", debug_file_path, LEVELS[debug_level])
     elif "pydevd" in sys.modules:
-        setup_logger("default", debug_file_path, logging.DEBUG)
+        setup_logger("default", debug_file_path, logging.INFO)
     else:
         setup_logger("default", debug_file_path, logging.INFO)
     file_content = []

tests/test_clean_and_list.py

@@ -0,0 +1,127 @@
+import unittest
+from tricc_oo.models.base import (
+    TriccOperator, TriccOperation, TriccStatic, TriccReference,
+    clean_and_list, not_clean
+)
+
+
+class TestCleanAndList(unittest.TestCase):
+
+    def test_empty_list(self):
+        """Test with empty list"""
+        result = clean_and_list([])
+        self.assertEqual(result, [])
+
+    def test_single_true(self):
+        """Test single TRUE is removed"""
+        result = clean_and_list([TriccStatic(True)])
+        self.assertEqual(result, [])
+
+    def test_single_false(self):
+        """Test single FALSE returns [FALSE]"""
+        result = clean_and_list([TriccStatic(False)])
+        self.assertEqual(result, [TriccStatic(False)])
+
+    def test_mixed_true_false(self):
+        """Test TRUE and FALSE returns [FALSE]"""
+        result = clean_and_list([TriccStatic(True), TriccStatic(False)])
+        self.assertEqual(result, [TriccStatic(False)])
+
+    def test_and_flattening(self):
+        """Test AND operations are flattened"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        c = TriccReference("c")
+        and_op = TriccOperation(TriccOperator.AND, [a, b])
+        result = clean_and_list([and_op, c])
+        expected = sorted([a, b, c], key=str)
+        self.assertEqual(result, expected)
+
+    def test_nested_and_flattening(self):
+        """Test nested AND operations are flattened"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        c = TriccReference("c")
+        d = TriccReference("d")
+        inner_and = TriccOperation(TriccOperator.AND, [a, b])
+        outer_and = TriccOperation(TriccOperator.AND, [inner_and, c])
+        result = clean_and_list([outer_and, d])
+        expected = sorted([a, b, c, d], key=str)
+        self.assertEqual(result, expected)
+
+    def test_contradiction_detection_exists(self):
+        """Test EXISTS(a) and NOTEXISTS(a) returns [FALSE]"""
+        a = TriccReference("a")
+        exists_a = TriccOperation(TriccOperator.EXISTS, [a])
+        not_exists_a = TriccOperation(TriccOperator.NOTEXISTS, [a])
+        result = clean_and_list([exists_a, not_exists_a])
+        self.assertEqual(result, [TriccStatic(False)])
+
+    def test_contradiction_detection_boolean_ops(self):
+        """Test boolean operation and its negation returns [FALSE]"""
+        a = TriccReference("a")
+        is_true_a = TriccOperation(TriccOperator.ISTRUE, [a])
+        is_false_a = TriccOperation(TriccOperator.ISFALSE, [a])
+        result = clean_and_list([is_true_a, is_false_a])
+        self.assertEqual(result, [TriccStatic(False)])
+
+    def test_remove_trues(self):
+        """Test TRUE values are removed"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        result = clean_and_list([a, TriccStatic(True), b])
+        expected = sorted([a, b], key=str)
+        self.assertEqual(result, expected)
+
+    def test_not_and_optimization_simple(self):
+        """Test NOT(AND(a, b)) with a present removes a from AND"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        not_and = TriccOperation(TriccOperator.NOT, [
+            TriccOperation(TriccOperator.AND, [a, b])
+        ])
+        result = clean_and_list([a, not_and])
+        # Should simplify NOT(AND(b)) which is equivalent to OR(NOT(b))
+        # But let's see what the current logic does
+        expected = sorted([a, not_and], key=str)
+        self.assertEqual(result, expected)
+
+    def test_basic_uniqueness(self):
+        """Test duplicate elements are removed"""
+        a = TriccReference("a")
+        result = clean_and_list([a, a, a])
+        self.assertEqual(result, [a])
+
+    def test_mixed_types(self):
+        """Test with mixed reference and static types"""
+        ref = TriccReference("test")
+        static = TriccStatic("value")
+        result = clean_and_list([ref, static, TriccStatic(True)])
+        expected = sorted([ref, static], key=str)
+        self.assertEqual(result, expected)
+
+    def test_false_with_others(self):
+        """Test FALSE with other elements returns [FALSE]"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        result = clean_and_list([a, TriccStatic(False), b])
+        self.assertEqual(result, [TriccStatic(False)])
+
+    def test_only_trues(self):
+        """Test list of only TRUEs returns empty"""
+        result = clean_and_list([TriccStatic(True), TriccStatic(True)])
+        self.assertEqual(result, [])
+
+    def test_complex_and_flattening(self):
+        """Test complex AND flattening with TRUEs and duplicates"""
+        a = TriccReference("a")
+        b = TriccReference("b")
+        c = TriccReference("c")
+        and_op = TriccOperation(TriccOperator.AND, [a, TriccStatic(True), b])
+        result = clean_and_list([and_op, c, TriccStatic(True)])
+        expected = sorted([a, b, c], key=str)
+        self.assertEqual(result, expected)
+
+
+if __name__ == "__main__":
+    unittest.main()

tricc_oo/models/base.py

@@ -603,7 +603,7 @@ def clean_and_list(argv):
     internal = list(set(argv))
     for a in internal:
         for b in internal[internal.index(a) + 1:]:
-            if not_clean(b) == a:
+            if not_clean(a) == b or not_clean(b) == a:
                 return [TriccStatic(False)]
     return sorted(list(set(argv)), key=str)
 
@@ -777,4 +777,384 @@ def nand_join(left, right):
         return and_join([left, not_clean(right)])
 
 
+def simplify_with_sympy(operation):
+    """
+    Simplify a TriccOperation using SymPy boolean and algebraic operations.
+
+    This enhanced version maps Tricc operators to actual SymPy operations/symbols
+    instead of treating them as placeholders, enabling sophisticated mixed-domain
+    simplifications.
+
+    Args:
+        operation: TriccOperation to simplify
+
+    Returns:
+        Simplified TriccOperation or original if no simplification possible
+    """
+    # Step 1: Check if operation contains operations that can be simplified
+    if not isinstance(operation, TriccOperation):
+        return operation
+
+    try:
+        import sympy as sp
+        from sympy.logic.boolalg import simplify_logic
+        from sympy import Add, Mul, Pow, Eq, Ne, And, Or, Not, Gt, Ge, Lt, Le
+        from sympy.functions import Abs, sign
+    except ImportError:
+        logger.warning("SymPy not available, skipping algebraic simplification")
+        return operation
+
+    # Step 2: Create comprehensive Tricc-to-SymPy operator mapping
+    tricc_to_sympy_map = {
+        # Boolean operations - treat as symbols to preserve structure
+        TriccOperator.AND: And,
+        TriccOperator.OR: Or,
+        TriccOperator.NOT: Not,
+        TriccOperator.ISTRUE: None,  # Will be treated as symbol
+        TriccOperator.ISFALSE: None,  # Will be treated as symbol
+        TriccOperator.EXISTS: None,  # Will be treated as symbol
+        TriccOperator.NOTEXISTS: None,  # Will be treated as symbol
+        TriccOperator.ISNOTTRUE: None,  # Will be treated as symbol
+        TriccOperator.ISNOTFALSE: None,  # Will be treated as symbol
+
+        # Arithmetic operations
+        TriccOperator.PLUS: Add,
+        TriccOperator.MINUS: lambda *args: Add(args[0], Mul(-1, args[1])) if len(args) == 2 else Mul(-1, args[0]),
+        TriccOperator.MULTIPLIED: Mul,
+        TriccOperator.DIVIDED: lambda x, y: Mul(x, Pow(y, -1)),
+        TriccOperator.MODULO: lambda x, y: x % y,  # Modulo
+
+        # Comparison operations
+        TriccOperator.EQUAL: Eq,
+        TriccOperator.NOTEQUAL: Ne,
+        TriccOperator.MORE: Gt,
+        TriccOperator.LESS: Lt,
+        TriccOperator.MORE_OR_EQUAL: Ge,
+        TriccOperator.LESS_OR_EQUAL: Le,
+
+        # Numeric operations
+        TriccOperator.ROUND: lambda x: sp.round(x),
+        TriccOperator.CAST_NUMBER: lambda x: x,  # Identity for numbers
+        TriccOperator.CAST_INTEGER: lambda x: sp.floor(x),
+
+        # Special operations (placeholders for now)
+        TriccOperator.COALESCE: None,  # Will use placeholder
+        TriccOperator.CONCATENATE: None,  # Will use placeholder
+        TriccOperator.CASE: None,  # Will use placeholder
+        TriccOperator.IFS: None,  # Will use placeholder
+    }
+
+    # Step 3: Create reference mapping with structural keys
+    ref_counter = 0
+    ref_map = {}  # SymPy symbol -> actual reference
+    reverse_map = {}  # structural key -> SymPy symbol
+
+    def get_structural_key(ref):
+        """Generate a canonical key based on structural equality"""
+        if isinstance(ref, TriccOperation):
+            ref_keys = [get_structural_key(r) for r in ref.reference]
+            return f"op_{ref.operator}_{'_'.join(ref_keys)}"
+        elif isinstance(ref, TriccReference):
+            return f"ref_{ref.value}"
+        elif isinstance(ref, TriccStatic):
+            return f"static_{ref.value}"
+        elif hasattr(ref, 'id'):
+            return f"{ref.__class__.__name__}_{ref.id}"
+        else:
+            return str(ref)
+
+    def get_sympy_symbol(ref):
+        """Get or create SymPy symbol for a reference"""
+        nonlocal ref_counter
+        ref_key = get_structural_key(ref)
+        if ref_key in reverse_map:
+            return reverse_map[ref_key]
+
+        # Create unique symbol name
+        if hasattr(ref, 'reference') and isinstance(ref.reference, (list, OrderedSet)):
+            # For operations, create path-based name
+            path_parts = []
+            current = ref
+            depth = 0
+            while hasattr(current, 'reference') and depth < 3:
+                if isinstance(current.reference, (list, OrderedSet)) and len(current.reference) > 0:
+                    path_parts.insert(0, str(len(current.reference)))
+                    current = current.reference[0]
+                    depth += 1
+                else:
+                    break
+            if path_parts:
+                symbol_name = f"r_{'_'.join(path_parts)}"
+            else:
+                symbol_name = f"r_{ref_counter}"
+        else:
+            symbol_name = f"r_{ref_counter}"
+
+        ref_counter += 1
+        symbol = sp.Symbol(symbol_name)
+        ref_map[symbol] = ref
+        reverse_map[ref_key] = symbol
+        return symbol
+
+    def tricc_to_sympy_expr(op):
+        """Convert TriccOperation to SymPy expression"""
+        if isinstance(op, TriccOperation):
+            # Special handling for boolean operations
+            if op.operator == TriccOperator.ISTRUE:
+                # istrue(x) becomes a symbol for the entire operation
+                return get_sympy_symbol(op)
+            elif op.operator == TriccOperator.ISNOTTRUE:
+                # isnottrue(x) becomes not(istrue(x))
+                if len(op.reference) == 1:
+                    istrue_op = TriccOperation(TriccOperator.ISTRUE, op.reference)
+                    istrue_symbol = get_sympy_symbol(istrue_op)
+                    return Not(istrue_symbol)
+                else:
+                    return get_sympy_symbol(op)
+            elif op.operator == TriccOperator.NOT and len(op.reference) == 1:
+                # Handle NOT(boolean_operation) by applying SymPy to inner and wrapping
+                inner = op.reference[0]
+                if isinstance(inner, TriccOperation) and inner.get_datatype() == "boolean":
+                    # Apply SymPy to the inner boolean expression
+                    inner_sympy = tricc_to_sympy_expr(inner)
+                    if inner_sympy != get_sympy_symbol(inner):
+                        # Inner was simplified, wrap with NOT
+                        return Not(inner_sympy)
+                    else:
+                        # Inner wasn't simplified, return as symbol
+                        return get_sympy_symbol(op)
+                else:
+                    # Not a boolean operation, handle normally
+                    sympy_op = tricc_to_sympy_map.get(op.operator)
+                    if sympy_op is None:
+                        return get_sympy_symbol(op)
+
+                    sympy_refs = [tricc_to_sympy_expr(ref) for ref in op.reference]
+                    if callable(sympy_op):
+                        try:
+                            if len(sympy_refs) == 1:
+                                return sympy_op(sympy_refs[0])
+                            elif len(sympy_refs) == 2:
+                                return sympy_op(sympy_refs[0], sympy_refs[1])
+                            else:
+                                result = sympy_refs[0]
+                                for ref in sympy_refs[1:]:
+                                    result = sympy_op(result, ref)
+                                return result
+                        except Exception as e:
+                            logger.debug(f"Failed to apply {sympy_op} to {sympy_refs}: {e}")
+                            return get_sympy_symbol(op)
+                    else:
+                        try:
+                            return sympy_op(*sympy_refs)
+                        except Exception as e:
+                            logger.debug(f"Failed to create {sympy_op} with {sympy_refs}: {e}")
+                            return get_sympy_symbol(op)
+            else:
+                # Normal operation handling
+                sympy_op = tricc_to_sympy_map.get(op.operator)
+
+                if sympy_op is None:
+                    # Use placeholder for unmapped operations
+                    return get_sympy_symbol(op)
+
+                # Convert references to SymPy expressions
+                sympy_refs = [tricc_to_sympy_expr(ref) for ref in op.reference]
+
+                # Apply the SymPy operation
+                if callable(sympy_op):
+                    try:
+                        if len(sympy_refs) == 1:
+                            return sympy_op(sympy_refs[0])
+                        elif len(sympy_refs) == 2:
+                            return sympy_op(sympy_refs[0], sympy_refs[1])
+                        else:
+                            # For operations with multiple args, apply sequentially
+                            result = sympy_refs[0]
+                            for ref in sympy_refs[1:]:
+                                result = sympy_op(result, ref)
+                            return result
+                    except Exception as e:
+                        logger.debug(f"Failed to apply {sympy_op} to {sympy_refs}: {e}")
+                        return get_sympy_symbol(op)
+                else:
+                    # Direct SymPy operation class
+                    try:
+                        return sympy_op(*sympy_refs)
+                    except Exception as e:
+                        logger.debug(f"Failed to create {sympy_op} with {sympy_refs}: {e}")
+                        return get_sympy_symbol(op)
+
+        elif isinstance(op, TriccStatic):
+            if isinstance(op.value, bool):
+                return sp.true if op.value else sp.false
+            elif isinstance(op.value, (int, float)):
+                return sp.S(op.value)
+            else:
+                return get_sympy_symbol(op)
+        else:
+            # References and other objects
+            return get_sympy_symbol(op)
+
+    def sympy_expr_to_tricc(expr):
+        """Convert SymPy expression back to TriccOperation using expression tree"""
+        if isinstance(expr, sp.Symbol):
+            # Direct symbol lookup
+            if expr in ref_map:
+                return ref_map[expr]
+            else:
+                # This shouldn't happen, but handle gracefully
+                return TriccReference(str(expr))
+
+        elif expr is sp.true:
+            return TriccStatic(True)
+        elif expr is sp.false:
+            return TriccStatic(False)
+
+        elif isinstance(expr, (sp.Integer, sp.Float)):
+            return TriccStatic(float(expr))
+
+
+
+        elif isinstance(expr, And):
+            args = [sympy_expr_to_tricc(arg) for arg in expr.args]
+            return and_join(args)
+
+        elif isinstance(expr, Or):
+            args = [sympy_expr_to_tricc(arg) for arg in expr.args]
+            return or_join(args)
+
+        elif isinstance(expr, Not):
+            inner = sympy_expr_to_tricc(expr.args[0])
+            return TriccOperation(TriccOperator.NOT, [inner])
+
+        elif isinstance(expr, Add):
+            if len(expr.args) == 2:
+                left, right = [sympy_expr_to_tricc(arg) for arg in expr.args]
+                # Check if right is negative (indicating subtraction)
+                if isinstance(right, TriccOperation) and right.operator == TriccOperator.MINUS and len(right.reference) == 1:
+                    return TriccOperation(TriccOperator.MINUS, [left, right.reference[0]])
+                else:
+                    return TriccOperation(TriccOperator.PLUS, [left, right])
+            else:
+                # Multiple addition
+                args = [sympy_expr_to_tricc(arg) for arg in expr.args]
+                return TriccOperation(TriccOperator.PLUS, args)
+
+        elif isinstance(expr, Mul):
+            if len(expr.args) == 2:
+                left, right = [sympy_expr_to_tricc(arg) for arg in expr.args]
+                # Check for division (multiplication by reciprocal)
+                if isinstance(right, TriccOperation) and right.operator == TriccOperator.DIVIDED:
+                    if len(right.reference) == 1:
+                        return TriccOperation(TriccOperator.DIVIDED, [left, right.reference[0]])
+                else:
+                    return TriccOperation(TriccOperator.MULTIPLIED, [left, right])
+            else:
+                # Multiple multiplication
+                args = [sympy_expr_to_tricc(arg) for arg in expr.args]
+                return TriccOperation(TriccOperator.MULTIPLIED, args)
+
+        elif isinstance(expr, Pow):
+            # Handle division (x^(-1) = 1/x)
+            if len(expr.args) == 2 and expr.args[1] == -1:
+                numerator = sympy_expr_to_tricc(expr.args[0])
+                denominator = TriccStatic(1)
+                return TriccOperation(TriccOperator.DIVIDED, [numerator, denominator])
+            else:
+                # Other powers - fallback to placeholder
+                return TriccReference(str(expr))
+
+        elif isinstance(expr, (Eq, Ne, Lt, Le, Gt, Ge)):
+            left, right = [sympy_expr_to_tricc(arg) for arg in expr.args]
+            op_map = {
+                Eq: TriccOperator.EQUAL,
+                Ne: TriccOperator.NOTEQUAL,
+                Lt: TriccOperator.LESS,
+                Le: TriccOperator.LESS_OR_EQUAL,
+                Gt: TriccOperator.MORE,
+                Ge: TriccOperator.MORE_OR_EQUAL,
+            }
+            operator = op_map.get(type(expr), TriccOperator.EQUAL)
+            return TriccOperation(operator, [left, right])
+
+        else:
+            # Unknown SymPy expression type - fallback to string representation
+            logger.debug(f"Unknown SymPy expression type: {type(expr)}, falling back to placeholder")
+            return TriccReference(str(expr))
+
+    # Step 4: Apply custom boolean simplifications first
+    if operation.get_datatype() == "boolean":
+        # Apply our custom boolean simplifications
+        custom_simplified = apply_boolean_simplifications(operation)
+        if custom_simplified != operation:
+            logger.debug(f"Custom boolean simplification: {operation} -> {custom_simplified}")
+            return custom_simplified
+
+    # Step 5: Convert to SymPy and simplify
+    try:
+        sympy_expr = tricc_to_sympy_expr(operation)
+        logger.debug(f"Original SymPy expression: {sympy_expr}")
+
+        # Apply appropriate simplification based on expression type
+        if operation.get_datatype() == "boolean":
+            # Use boolean algebra simplification
+            simplified_expr = simplify_logic(sympy_expr)
+        else:
+            # Use general algebraic simplification
+            simplified_expr = sp.simplify(sympy_expr)
+
+        logger.debug(f"Simplified SymPy expression: {simplified_expr}")
+
+        # Step 6: Convert back to TriccOperation if different
+        if simplified_expr != sympy_expr:
+            reconstructed = sympy_expr_to_tricc(simplified_expr)
+            logger.debug(f"SymPy simplified {operation} to {reconstructed}")
+            return reconstructed
+
+    except Exception as e:
+        logger.warning(f"SymPy simplification failed for {operation}: {e}")
+
+    return operation
+
+
+def apply_boolean_simplifications(operation):
+    """Apply custom boolean simplifications that SymPy might miss"""
+    if not isinstance(operation, TriccOperation):
+        return operation
+
+    if operation.operator == TriccOperator.OR:
+        # Apply clean_or_list which includes our pattern recognition
+        cleaned_list = clean_or_list(set(operation.reference))
+        if len(cleaned_list) == 1:
+            return cleaned_list[0]
+        elif len(cleaned_list) != len(operation.reference):
+            return TriccOperation(TriccOperator.OR, cleaned_list)
+
+    elif operation.operator == TriccOperator.AND:
+        # Apply clean_and_list
+        cleaned_list = clean_and_list(operation.reference)
+        if len(cleaned_list) == 1:
+            return cleaned_list[0]
+        elif len(cleaned_list) != len(operation.reference):
+            return TriccOperation(TriccOperator.AND, cleaned_list)
+
+    # Recursively apply to sub-operations
+    simplified_refs = []
+    changed = False
+    for ref in operation.reference:
+        if isinstance(ref, TriccOperation):
+            simplified_ref = apply_boolean_simplifications(ref)
+            if simplified_ref != ref:
+                changed = True
+            simplified_refs.append(simplified_ref)
+        else:
+            simplified_refs.append(ref)
+
+    if changed:
+        return TriccOperation(operation.operator, simplified_refs)
+
+    return operation
+
+
 TriccGroup.update_forward_refs()

tricc_oo/strategies/input/drawio.py

@@ -285,6 +285,7 @@ class DrawioStrategy(BaseInputStrategy):
             else:
                 # all good, only one target node found
                 linked_target_node = link_in_list[0]
+
                 # steal the edges
                 replace_node(node, linked_target_node, page)
 

tricc_oo/strategies/output/xls_form.py

@@ -13,7 +13,8 @@ from pyxform import create_survey_from_xls
 from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.base import (
     TriccOperator,
-    TriccOperation, TriccStatic, TriccReference
+    TriccOperation, TriccStatic, TriccReference,
+    simplify_with_sympy
 )
 from tricc_oo.models.ordered_set import OrderedSet
 from tricc_oo.models.calculate import (
@@ -379,6 +380,9 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return processed_nodes
 
     def get_tricc_operation_expression(self, operation):
+        # Apply SymPy boolean simplification for boolean operations
+        #operation = simplify_with_sympy(operation)
+        
         ref_expressions = []
         original_references = []
         if not hasattr(operation, "reference"):

tricc_oo/visitors/tricc.py

@@ -126,7 +126,7 @@ def get_last_version(name, processed_nodes, _list=None):
 def get_node_expressions(node, processed_nodes, process=None):
     get_overall_exp = issubclass(
         node.__class__,
-        (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)
+        (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis, TriccNodeActivity)
     ) and not isinstance(node, (TriccNodeDisplayBridge))
     expression = None
     # in case of recursive call processed_nodes will be None
@@ -176,7 +176,7 @@ def get_version_inheritance(node, all_prev_versions, processed_nodes):
                 expression = node.expression or node.expression_reference or getattr(node, "relevance", None)
                 # Merge with ALL previous versions, not just the last one
                 if all_prev_versions:
-                    expression = merge_all_expressions(expression, all_prev_versions)
+                    expression = merge_expressions(expression, *all_prev_versions)
                 if node.expression:
                     node.expression = expression
                 elif node.expression_reference:
@@ -216,39 +216,15 @@ def get_version_inheritance(node, all_prev_versions, processed_nodes):
             node.expression = TriccOperation(TriccOperator.COALESCE, coalesce_operands)
 
 
-def merge_expression(expression, last_version):
+def merge_expressions(expression, last_version, *argv):
     datatype = expression.get_datatype()
     if datatype == "boolean":
-        expression = or_join([TriccOperation(TriccOperator.ISTRUE, [last_version]), expression])
+        expression = or_join([TriccOperation(TriccOperator.ISTRUE, [last_version, *argv]), expression])
 
     elif datatype == "number":
-        expression = TriccOperation(TriccOperator.PLUS, [last_version, expression])
+        expression = TriccOperation(TriccOperator.PLUS, [last_version, *argv, expression])
     else:
-        expression = TriccOperation(TriccOperator.COALESCE, [last_version, expression])
-    return expression
-
-
-def merge_all_expressions(expression, all_versions):
-    """
-    Merge an expression with ALL previous versions, not just the last one.
-    This ensures inheritance works even when intermediate versions weren't evaluated
-    due to activity relevance conditions.
-    """
-    if not all_versions:
-        return expression
-    
-    datatype = expression.get_datatype() if expression else "unknown"
-    
-    if datatype == "boolean":
-        expression = or_join([expression, *all_versions])
-    
-    else:
-        # COALESCE through all previous versions, then the current expression
-        coalesce_operands = list(all_versions)
-        if expression:
-            coalesce_operands.append(expression)
-        expression = TriccOperation(TriccOperator.COALESCE, coalesce_operands)
-    
+        expression = TriccOperation(TriccOperator.COALESCE, [expression, last_version, *argv])
     return expression
 
 
@@ -315,14 +291,23 @@ def load_calculate(
                             add_used_calculate(node, r, calculates, used_calculates, processed_nodes)
 
             if last_version and hasattr(node, "relevance"):
+                last_expressions_other_activity = [
+                    and_join([TriccOperation(TriccOperator.ISTRUE,[l]),l.activity.root]) for l in  all_prev_versions if (
+                        node.is_sequence_defined and
+                        node.activity.base_instance != l.activity.base_instance
+                    )
+                ]
+                last_expression_same_activity = [
+                    TriccOperation(TriccOperator.ISTRUE,l) for l in  all_prev_versions if (
+                        node.is_sequence_defined and
+                        node.activity == l.activity
+                    )
+                ]
+                last_version_relevance = [*last_expressions_other_activity, *last_expression_same_activity]
                 if isinstance(node, TriccNodeInputModel):
                     version_relevance = TriccOperation(TriccOperator.ISNULL, [last_version])
-                elif last_version.relevance:
-                    version_relevance = not_clean(last_version.relevance)
-                elif last_version.activity.relevance:
-                    version_relevance = not_clean(
-                        last_version.activity.relevance,
-                    )
+                elif last_version_relevance:
+                    version_relevance = not_clean(or_join(last_version_relevance))
                 else:
                     version_relevance = None
 
@@ -582,7 +567,7 @@ def generate_calculates(node, calculates, used_calculates, processed_nodes, proc
             node.activity.calculates.append(calc_node)
             last_version = set_last_version_false(calc_node, processed_nodes)
             if last_version:
-                calc_node.expression = merge_expression(calc_node.expression, last_version)
+                calc_node.expression = merge_expressions(calc_node.expression, last_version)
             processed_nodes.add(calc_node)
             logger.debug(
                 "generate_save_calculate:{}:{} as {}".format(
@@ -615,7 +600,7 @@ def generate_calculates(node, calculates, used_calculates, processed_nodes, proc
                 node.activity.calculates.append(calc_node)
                 last_version = set_last_version_false(calc_node, processed_nodes)
                 if last_version:
-                    calc_node.expression = merge_expression(calc_node.expression, last_version)
+                    calc_node.expression = merge_expressions(calc_node.expression, last_version)
                 processed_nodes.add(calc_node)
                 list_calc.append(calc_node)
                 node.activity.nodes[calc_node.id] = calc_node
@@ -1988,14 +1973,25 @@ def get_node_expression(in_node, processed_nodes, get_overall_exp=False, is_prev
         (not is_prev or not ONE_QUESTION_AT_A_TIME)
         and hasattr(node, "relevance")
         and isinstance(node.relevance, (TriccOperation, TriccStatic))
+        and getattr(node, 'is_sequence_defined', False)
+        and not get_overall_exp
     ):
         expression = node.relevance
-    elif ONE_QUESTION_AT_A_TIME and is_prev and not get_overall_exp and hasattr(node, "required") and node.required:
+    elif (
+        ONE_QUESTION_AT_A_TIME
+        and is_prev and not get_overall_exp 
+        and hasattr(node, "required") 
+        and node.required
+        and getattr(node, 'is_sequence_defined', False)
+    ):
         expression = get_required_node_expression(node)
-
     if expression is None:
         expression = get_prev_node_expression(
-            node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
+            node,
+            activity=node.activity,
+            processed_nodes=processed_nodes,
+            get_overall_exp=get_overall_exp,
+            process=process
         )
         # in_node not in processed_nodes is need for calculates that can but run after the end of the activity
     # if isinstance(node, TriccNodeActivitiy) and not prev:
@@ -2218,8 +2214,9 @@ def create_determine_diagnosis_activity(diags):
     return activity
 
 
-def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, excluded_name=None, process=None):
+def get_prev_node_expression(node, activity, processed_nodes, get_overall_exp=False, excluded_name=None, process=None):
     expression = None
+    sub = None
     if node is None:
         pass
     # when getting the prev node, we calculate the
@@ -2228,12 +2225,19 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
         expression_inputs = clean_or_list(expression_inputs)
     else:
         expression_inputs = []
-    prev_activities = {}
+    prev_activities = {node.activity.id: []}
+    # sorting prev_nodes per activity
+   
     for prev_node in node.prev_nodes:
         if prev_node.activity.id not in prev_activities:
             prev_activities[prev_node.activity.id] = []
+        if isinstance(prev_node, TriccNodeActivity):
+            for a_prev_node in prev_node.prev_nodes:
+                # if we share the calling contect of the activity
+                if a_prev_node.activity == node.activity:
+                    prev_activities[node.activity.id].append(a_prev_node)
         prev_activities[prev_node.activity.id].append(prev_node)
-
+    # get the or_list expression of all the node per activity
     for act_id in prev_activities:
         act_expression_inputs = []
         none_sequence_defined_prev_node = False
@@ -2250,29 +2254,36 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
                 )
             ):
                 # the rhombus should calculate only reference
+                # expression from one prev node
                 sub = get_node_expression(
                     prev_node,
                     processed_nodes=processed_nodes,
                     get_overall_exp=get_overall_exp,
                     is_prev=True,
-                    process=get_overall_exp,
-                )
-                if isinstance(node, TriccNodeActivity) or get_overall_exp:
+                    process=process,
+                ) or TriccStatic(True)
+                # if it is an activity or overall then we add the sub to act expression 
+                # else we update directly the node releavance subs
+                if node.activity.id != act_id or get_overall_exp:
                     add_sub_expression(act_expression_inputs, sub)
                 else:
                     add_sub_expression(expression_inputs, sub)
-
+        # if cur prev node part of prev act elvaluated have some relevance we make an AND with prev act relevance
         if act_expression_inputs:
             act_sub = or_join(act_expression_inputs)
             # if there is condition fallback on the calling activity condition
-            act_relevance = get_node_expression(
-                    prev_node.activity,
-                    processed_nodes=processed_nodes,
-                    get_overall_exp=get_overall_exp,
-                    is_prev=True,
-                    negate=False,
-                    process=process,
-                )
+            if prev_node.activity.relevance and prev_node.activity.relevance != TriccStatic(True):
+                act_relevance = TriccOperation(TriccOperator.ISTRUE, [prev_node.activity.root])
+            else:
+                act_relevance = TriccStatic(True)
+            # get_node_expression(
+            #         prev_node.activity,
+            #         processed_nodes=processed_nodes,
+            #         get_overall_exp=get_overall_exp,
+            #         is_prev=True,
+            #         negate=False,
+            #         process=process,
+            #     )
             if act_sub == TriccStatic(True):
                 act_sub = act_relevance
             elif act_relevance != TriccStatic(True) and none_sequence_defined_prev_node:
@@ -2557,6 +2568,7 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
     # because calculate are not the the activity group
     elif isinstance(node, (TriccNodeActivityStart)) and get_overall_exp:
         expression = get_prev_node_expression(
+            node.activity,
             node.activity,
             processed_nodes=processed_nodes,
             get_overall_exp=get_overall_exp,
@@ -2605,7 +2617,7 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
         expression = node.expression_reference
     elif expression is None:
         expression = get_prev_node_expression(
-            node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
+            node, node.activity, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
         )
 
     # manage the generic negation

{tricc_oo-1.6.25.dist-info → tricc_oo-1.6.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.25
+Version: 1.6.27
 Summary: Python library that converts CDSS L2 in L3
 Project-URL: Homepage, https://github.com/SwissTPH/tricc
 Project-URL: Issues, https://github.com/SwissTPH/tricc/issues
@@ -25,6 +25,7 @@ Requires-Dist: antlr4-tools==0.2.1
 Requires-Dist: beautifulsoup4
 Requires-Dist: ocldev
 Requires-Dist: pyxform
+Requires-Dist: Sympy
 Dynamic: license-file
 
 # TRICC-OO

{tricc_oo-1.6.25.dist-info → tricc_oo-1.6.27.dist-info}/RECORD

@@ -1,4 +1,5 @@
-tests/build.py,sha256=Qbxvjkj_Wk2nQ-WjaMGiE1FIe3SRmJMRIgeoMoxqlfQ,6748
+tests/build.py,sha256=d_8QDUem7e77u_1BRE96xn9VXbG8N4L9pgpgG9fVWRw,6747
+tests/test_clean_and_list.py,sha256=S8CcYHbnttToZy1COkN4PWtIiHuOFCD3dY9gFiVuxSI,4892
 tests/test_cql.py,sha256=IRfjrmcxMn60XlAQLUur-7OUELs1NioqxRXWcOf8QcQ,5678
 tests/to_ocl.py,sha256=4e-i65K3UM6wHgdVcrZcM9AyL1bahIsXJiZTXhhHgQk,2048
 tricc_oo/__init__.py,sha256=oWCE1ubmC_6iqaWOMgTei4eXVQgV202Ia-tXS1NnW_4,139
@@ -15,7 +16,7 @@ tricc_oo/converters/cql/cqlListener.py,sha256=fA7-8DcS2Q69ckwjdg57-OfFHBxjTZFdoS
 tricc_oo/converters/cql/cqlParser.py,sha256=x3KdrwX9nwENSEJ5Ex7_l5NMnu3kWBO0uLdYu4moTq0,414745
 tricc_oo/converters/cql/cqlVisitor.py,sha256=iHuup2S7OGSVWLEcI4H3oecRqgXztC1sKnew_1P2iGY,33880
 tricc_oo/models/__init__.py,sha256=CgS52LLqdDIaXHvZy08hhu_VaYw80OEdfL_llM9ICBA,108
-tricc_oo/models/base.py,sha256=f5EQtTSJH9aPanqCc0qD6579TgAirzYaZ5BtQ2Iu0xw,26136
+tricc_oo/models/base.py,sha256=N2gPlAwCQxIiGJQjfu_49c9DkO3EjgJ1LirFgPNkSfQ,42422
 tricc_oo/models/calculate.py,sha256=uNP0IDUqPQcJq9Co05H8eX5wbR_DikSxuOHxfVE5Dxg,8018
 tricc_oo/models/lang.py,sha256=ZMRwdoPWe01wEDhOM0uRk-6rt3BkoAAZM8mZ61--s3A,2265
 tricc_oo/models/ocl.py,sha256=MybSeB6fgCOUVJ4aektff0vrrTZsyfwZ2Gt_pPBu_FY,8728
@@ -29,23 +30,23 @@ tricc_oo/serializers/xls_form.py,sha256=SZPvZK6y4l_2v3HuGWITHmKd5rTClhHWvbUU3Ren
 tricc_oo/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/base_input_strategy.py,sha256=BEODXS74na1QRRcJVQ4cxiD8F7uRqaLyhE3QzKpGVvk,3891
-tricc_oo/strategies/input/drawio.py,sha256=uXAUPhXOeg0Uk_BNqlCqFBW4cWNox4VfH559bj1fhC0,12767
+tricc_oo/strategies/input/drawio.py,sha256=VCKAr_r-jJ_xJlyCMCH2-qSE2KIvc7fmR2y4X9QMv3k,12768
 tricc_oo/strategies/output/base_output_strategy.py,sha256=i9L5CVUqkEAMNyBsdHJ4xA7Nptr3myHr_fHHveDX1cU,8928
 tricc_oo/strategies/output/dhis2_form.py,sha256=jW9NW72_61ch1bHm8ShIH4xsJH-HMlZGPTT5txJxMUk,38278
 tricc_oo/strategies/output/fhir_form.py,sha256=hbL921pe1Doun4IQrJuZ_Sq2fCh98G3grYie5olC4uc,15740
 tricc_oo/strategies/output/html_form.py,sha256=qSleEZOMV_-Z04y-i-ucyd5rgAYWAyjPwMrw0IHtCRM,8604
 tricc_oo/strategies/output/openmrs_form.py,sha256=ne6TwAyhafR-WDs27QTKKFl85VD5sij_VEJtK6ZjOIE,28996
 tricc_oo/strategies/output/spice.py,sha256=QMeoismVC3PdbvwTK0PtUjWX9jl9780fbQIXn76fMXw,10761
-tricc_oo/strategies/output/xls_form.py,sha256=yz1G7Mdf4ZpdXaKU6YV8rjNQ288pwUzTh13aI5Up6AI,33884
+tricc_oo/strategies/output/xls_form.py,sha256=n_C9J1_FGcwtnXePBbPUd1OTuCpdbNEzt_o6sBGqsCg,34038
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=X00Lt5MzV8TX14dR4dFI1MqllI5S1e13bKbeysWM9uA,17435
 tricc_oo/strategies/output/xlsform_cht.py,sha256=66sTRqVL9ZUL8NpX2f0xCRQ-siUKcKphosR9y7wsbuM,28326
 tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=xm6SKirV3nMZvM2w54_zJcXAeAgAkq-EEqGEjnOWv6c,988
 tricc_oo/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tricc_oo/visitors/tricc.py,sha256=VL1Ds4a7gCA0V7Mo2qPipT2uV4dcXDK2_swLdxZavDA,114272
+tricc_oo/visitors/tricc.py,sha256=vZebJR4gF-VJxNv1qZeTU08VrzAMjMsTX58artHtZKI,115411
 tricc_oo/visitors/utils.py,sha256=j83aAq5s5atXi3OC0jc_uJd54a8XrHHmizeeEbWZQJg,421
 tricc_oo/visitors/xform_pd.py,sha256=ryAnI3V9x3eTmJ2LNsUZfvl0_yfCqo6oBgeSu-WPqaE,9613
-tricc_oo-1.6.25.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-tricc_oo-1.6.25.dist-info/METADATA,sha256=If9bVy3gEm3zT0OMh6UPuUJxsFndAk_MtcglJXUH4LQ,8600
-tricc_oo-1.6.25.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-tricc_oo-1.6.25.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.6.25.dist-info/RECORD,,
+tricc_oo-1.6.27.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+tricc_oo-1.6.27.dist-info/METADATA,sha256=JXCMTGTqMLUAzxIHCZ5JoXThXxyJCOzYJLC7qQAewlM,8621
+tricc_oo-1.6.27.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tricc_oo-1.6.27.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.6.27.dist-info/RECORD,,