tricc-oo 1.6.22__tar.gz → 1.6.23__tar.gz

{tricc_oo-1.6.22/tricc_oo.egg-info → tricc_oo-1.6.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.22
+Version: 1.6.23
 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

{tricc_oo-1.6.22 → tricc_oo-1.6.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tricc-oo"
-version = "1.6.22"
+version = "1.6.23"
 description = "Python library that converts CDSS L2 in L3"
 readme = "README.md"
 requires-python = ">=3.8"

{tricc_oo-1.6.22 → tricc_oo-1.6.23}/tricc_oo/models/base.py

@@ -217,6 +217,7 @@ class TriccNodeBaseModel(TriccBaseModel):
     expression_inputs: List[Expression] = []
     activity: Optional[FwTriccNodeBaseModel] = None
     ref_def: Optional[Union[int, str]] = None  # for medal creator
+    is_sequence_defined: bool = False
 
     class Config:
         use_enum_values = True  # <--

{tricc_oo-1.6.22 → tricc_oo-1.6.23}/tricc_oo/models/tricc.py

@@ -301,6 +301,7 @@ class TriccNodeDisplayModel(TriccNodeBaseModel):
 class TriccNodeNote(TriccNodeDisplayModel):
     tricc_type: TriccNodeType = TriccNodeType.note
     datatype: str = "string"
+    is_sequence_defined: bool = True
 
 
 class TriccNodeInputModel(TriccNodeDisplayModel):
@@ -308,6 +309,7 @@ class TriccNodeInputModel(TriccNodeDisplayModel):
     constraint_message: Optional[Union[str, Dict[str, str]]] = None
     constraint: Optional[Expression] = None
     save: Optional[str] = None  # contribute to another calculate
+    is_sequence_defined: bool = True
 
 
 class TriccNodeDate(TriccNodeInputModel):

{tricc_oo-1.6.22 → tricc_oo-1.6.23}/tricc_oo/visitors/tricc.py

@@ -158,19 +158,25 @@ def set_last_version_false(node, processed_nodes):
     return last_version
 
 
-def get_version_inheritance(node, last_version, processed_nodes):
-    # FIXME this is for XLS form where only calculate are evaluated
-    # for a activity that is not triggered
+def get_version_inheritance(node, all_prev_versions, processed_nodes):
+
+    # Updated to merge ALL previous versions, not just the last one
+    # This ensures inheritance works even when intermediate activities weren't triggered
+    
     if not issubclass(node.__class__, (TriccNodeInputModel)):
         node.last = True
         if issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeEnd)) and node.name is not None:
             # logger.debug("set last to false for node {}
             # and add its link it to next one".format(last_used_calc.get_name()))
             if node.prev_nodes:
-                set_prev_next_node(last_version, node)
+                # Set prev_next_node only with the immediate last version
+                for pv in  all_prev_versions:
+                    set_prev_next_node(pv, node)
             else:
                 expression = node.expression or node.expression_reference or getattr(node, "relevance", None)
-                expression = merge_expression(expression, last_version)
+                # Merge with ALL previous versions, not just the last one
+                if all_prev_versions:
+                    expression = merge_all_expressions(expression, all_prev_versions)
                 if node.expression:
                     node.expression = expression
                 elif node.expression_reference:
@@ -180,17 +186,21 @@ def get_version_inheritance(node, last_version, processed_nodes):
     else:
         node.last = False
 
-        # Create a calculate node that coalesces the previous saved value with the current node value
+        # Create a calculate node that coalesces all previous saved values with the current node value
         calc_id = generate_id(f"save_{node.save}")
+        
+        # Build reference list with current node and all previous versions
+        reference_list = [node] + (all_prev_versions if all_prev_versions else [])
+        
         calc = TriccNodeCalculate(
             id=calc_id,
             name=node.save,
             path_len=node.path_len + 1,
             expression_reference=TriccOperation(
                 TriccOperator.COALESCE,
-                [node, last_version],
+                reference_list,
             ),
-            reference=[node, last_version],
+            reference=reference_list,
             activity=node.activity,
             group=node.group,
             label=f"Save calculation for {node.label}",
@@ -201,7 +211,9 @@ def get_version_inheritance(node, last_version, processed_nodes):
         # set_last_version_false(calc, processed_nodes)
         processed_nodes.add(calc)
         if issubclass(node.__class__, TriccNodeInputModel):
-            node.expression = TriccOperation(TriccOperator.COALESCE, ["$this", last_version])
+            # Coalesce with all previous versions
+            coalesce_operands = ["$this"] + (all_prev_versions if all_prev_versions else [])
+            node.expression = TriccOperation(TriccOperator.COALESCE, coalesce_operands)
 
 
 def merge_expression(expression, last_version):
@@ -216,6 +228,30 @@ def merge_expression(expression, last_version):
     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(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)
+    
+    return expression
+
+
 def load_calculate(
     node, processed_nodes, stashed_nodes, calculates, used_calculates, warn=False, process=None, **kwargs
 ):
@@ -239,8 +275,14 @@ def load_calculate(
             # tricc diagnostic have the same name as proposed diag but will be serialised with different names
 
             last_version = set_last_version_false(node, processed_nodes)
+            # Get all previous versions from processed_nodes, not just the last one
+            node_name = node.name if not isinstance(node, TriccNodeEnd) else node.get_reference()
+            all_prev_versions = get_versions(node_name, processed_nodes)
+            # Exclude the current node itself
+            all_prev_versions = [v for v in all_prev_versions if v != node]
+
             if last_version:
-                last_version = get_version_inheritance(node, last_version, processed_nodes)
+                get_version_inheritance(node, all_prev_versions, processed_nodes)
 
             generate_calculates(node, calculates, used_calculates, processed_nodes=processed_nodes, process=process)
 
@@ -2194,9 +2236,9 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
 
     for act_id in prev_activities:
         act_expression_inputs = []
-        none_input_prev_node = False
+        none_sequence_defined_prev_node = False
         for prev_node in prev_activities[act_id]:
-            none_input_prev_node = none_input_prev_node or not issubclass(prev_node.__class__, TriccNodeInputModel)
+            none_sequence_defined_prev_node = none_sequence_defined_prev_node or not prev_node.is_sequence_defined
             if (
                 excluded_name is None
                 or prev_node != excluded_name
@@ -2232,8 +2274,8 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
                     negate=False,
                     process=process,
                 )
-            elif none_input_prev_node:
-                # For non-input nodes, AND the activity relevance with the prev expression
+            elif none_sequence_defined_prev_node:
+                # For nodes with is_sequence_defined = False, AND the activity relevance with the prev expression
                 activity_relevance = get_node_expression(
                     prev_node.activity,
                     processed_nodes=processed_nodes,
@@ -2554,15 +2596,6 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
 
     if isinstance(node.expression_reference, (TriccOperation, TriccStatic)):
         expression = node.expression_reference
-    elif node.reference is not None and node.expression_reference is not None:
-        expression = get_prev_node_expression(
-            node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
-        )
-        ref_expression = node.expression_reference.format(*[get_export_name(ref) for ref in node.reference])
-        if expression is not None and expression != "":
-            expression = and_join([expression, ref_expression])
-        else:
-            expression = ref_expression
     elif expression is None:
         expression = get_prev_node_expression(
             node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
@@ -2655,6 +2688,12 @@ def generate_calculate(node, processed_nodes, **kwargs):
     if node not in processed_nodes:
         if kwargs.get("warn", True):
             logger.debug("generation of calculate for node {}".format(node.get_name()))
+
+        # Set is_sequence_defined for calculate nodes based on dependencies
+        if issubclass(node.__class__, TriccNodeCalculateBase):
+            # Calculate node is sequence defined if ALL prev_nodes have is_sequence_defined = True
+            node.is_sequence_defined = all(prev_node.is_sequence_defined for prev_node in node.prev_nodes)
+
         if (
             hasattr(node, "expression")
             and (node.expression is None)

{tricc_oo-1.6.22 → tricc_oo-1.6.23/tricc_oo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.22
+Version: 1.6.23
 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