tricc-oo 1.6.26__py3-none-any.whl → 1.7.0.dev1__py3-none-any.whl

tricc_oo/visitors/tricc.py

@@ -56,9 +56,6 @@ from tricc_oo.converters.tricc_to_xls_form import get_list_names, get_export_nam
 logger = logging.getLogger("default")
 ONE_QUESTION_AT_A_TIME = False
 
-# Track the last group that was reordered to avoid unnecessary reordering
-_last_reordered_group = None
-
 
 def merge_node(from_node, to_node):
     if from_node.activity != to_node.activity:
@@ -124,10 +121,7 @@ def get_last_version(name, processed_nodes, _list=None):
 # node is the node to calculate
 # processed_nodes are the list of processed nodes
 def get_node_expressions(node, processed_nodes, process=None):
-    get_overall_exp = issubclass(
-        node.__class__,
-        (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)
-    ) and not isinstance(node, (TriccNodeDisplayBridge))
+    get_overall_exp = issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)) and not isinstance(node, (TriccNodeDisplayBridge))
     expression = None
     # in case of recursive call processed_nodes will be None
     if processed_nodes is None or is_ready_to_process(node, processed_nodes=processed_nodes):
@@ -158,25 +152,19 @@ def set_last_version_false(node, processed_nodes):
     return last_version
 
 
-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
-    
+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
     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 only with the immediate last version
-                for pv in  all_prev_versions:
-                    set_prev_next_node(pv, node)
+                set_prev_next_node(last_version, node)
             else:
                 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_expressions(expression, *all_prev_versions)
+                expression = merge_expression(expression, last_version)
                 if node.expression:
                     node.expression = expression
                 elif node.expression_reference:
@@ -185,25 +173,21 @@ def get_version_inheritance(node, all_prev_versions, processed_nodes):
                     node.relevance = expression
     else:
         node.last = False
-
-        # 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 [])
         
+                    # Create a calculate node that coalesces the previous saved value with the current node value
+        calc_id = generate_id(f"save_{node.save}")
         calc = TriccNodeCalculate(
             id=calc_id,
             name=node.save,
             path_len=node.path_len + 1,
             expression_reference=TriccOperation(
                 TriccOperator.COALESCE,
-                reference_list,
+                [TriccReference(node.save), last_version],
             ),
-            reference=reference_list,
+            reference=[TriccReference(n.name)],
             activity=node.activity,
             group=node.group,
-            label=f"Save calculation for {node.label}",
+            label=f"Save calculation for {n.label}",
             last=True,
         )
         node.activity.nodes[calc.id] = calc
@@ -211,20 +195,18 @@ def get_version_inheritance(node, all_prev_versions, processed_nodes):
         # set_last_version_false(calc, processed_nodes)
         processed_nodes.add(calc)
         if issubclass(node.__class__, TriccNodeInputModel):
-            # Coalesce with all previous versions
-            coalesce_operands = ["$this"] + (all_prev_versions if all_prev_versions else [])
-            node.expression = TriccOperation(TriccOperator.COALESCE, coalesce_operands)
+            node.expression = TriccOperation(TriccOperator.COALESCE, ["$this", last_version])
 
 
-def merge_expressions(expression, last_version, *argv):
+def merge_expression(expression, last_version):
     datatype = expression.get_datatype()
     if datatype == "boolean":
-        expression = or_join([TriccOperation(TriccOperator.ISTRUE, [last_version, *argv]), expression])
+        expression = or_join([TriccOperation(TriccOperator.ISTRUE, [last_version]), expression])
 
     elif datatype == "number":
-        expression = TriccOperation(TriccOperator.PLUS, [last_version, *argv, expression])
+        expression = TriccOperation(TriccOperator.PLUS, [last_version, expression])
     else:
-        expression = TriccOperation(TriccOperator.COALESCE, [expression, last_version, *argv])
+        expression = TriccOperation(TriccOperator.COALESCE, [last_version, expression])
     return expression
 
 
@@ -251,14 +233,8 @@ 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:
-                get_version_inheritance(node, all_prev_versions, processed_nodes)
+                last_version = get_version_inheritance(node, last_version, processed_nodes)
 
             generate_calculates(node, calculates, used_calculates, processed_nodes=processed_nodes, process=process)
 
@@ -426,11 +402,6 @@ def get_bridge_path(prev_nodes, node=None, edge_only=False):
         calc = TriccNodeDisplayBridge(**data)
     else:
         calc = TriccNodeBridge(**data)
-    if node:
-        priority = getattr(node, 'priority', None)
-        if priority:
-            calc.priority = priority
-    
     return calc
 
 
@@ -558,7 +529,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_expressions(calc_node.expression, last_version)
+                calc_node.expression = merge_expression(calc_node.expression, last_version)
             processed_nodes.add(calc_node)
             logger.debug(
                 "generate_save_calculate:{}:{} as {}".format(
@@ -591,7 +562,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_expressions(calc_node.expression, last_version)
+                    calc_node.expression = merge_expression(calc_node.expression, last_version)
                 processed_nodes.add(calc_node)
                 list_calc.append(calc_node)
                 node.activity.nodes[calc_node.id] = calc_node
@@ -831,7 +802,7 @@ def process_operation_reference(
     operation,
     node,
     processed_nodes,
-    calculates=None,
+    calculates,
     used_calculates=None,
     replace_reference=False,
     warn=False,
@@ -994,7 +965,6 @@ def walktrhough_tricc_node_processed_stached(
     warn=False,
     node_path=[],
     process=None,
-    loop_count=0,
     **kwargs,
 ):
     ended_activity = False
@@ -1160,10 +1130,7 @@ def walktrhough_tricc_node_processed_stached(
                     if nn not in stashed_nodes:
                         stashed_nodes.insert_at_top(nn)
         if not recursive:
-            global _last_reordered_group
-            if _last_reordered_group != node.group:
-                reorder_node_list(stashed_nodes, node.group, processed_nodes)
-                _last_reordered_group = node.group
+            reorder_node_list(stashed_nodes, node.group, processed_nodes)
 
     else:
         if prev_process and process and prev_process != process[0]:
@@ -1310,7 +1277,7 @@ def stashed_node_func(node, callback, recursive=False, **kwargs):
 
 
 # check if the all the prev nodes are processed
-def is_ready_to_process(in_node, processed_nodes, strict=True, local=False, loop_count=0):
+def is_ready_to_process(in_node, processed_nodes, strict=True, local=False):
     if isinstance(in_node, TriccNodeSelectOption):
         node = in_node.select
     elif isinstance(in_node, (TriccNodeActivityStart, TriccNodeMainStart)):
@@ -1321,38 +1288,36 @@ def is_ready_to_process(in_node, processed_nodes, strict=True, local=False, loop
     if hasattr(node, "prev_nodes"):
         # ensure the  previous node of the select are processed, not the option prev nodes
         for prev_node in node.prev_nodes:
-            if is_prev_processed(prev_node, node, processed_nodes, local, loop_count) is False:
+            if is_prev_processed(prev_node, node, processed_nodes, local) is False:
                 return False
     return True
 
 
-def is_prev_processed(prev_node, node, processed_nodes, local, loop_count=0):
+def is_prev_processed(prev_node, node, processed_nodes, local):
     if hasattr(prev_node, "select"):
-        return is_prev_processed(prev_node.select, node, processed_nodes, local, loop_count)
+        return is_prev_processed(prev_node.select, node, processed_nodes, local)
     if prev_node not in processed_nodes and (not local):
-        # Only log detailed failures when we suspect dependency loops (loop_count > 5)
-        if loop_count > 5:
-            if isinstance(prev_node, TriccNodeExclusive):
-                iterator = iter(prev_node.prev_nodes)
-                p_n_node = next(iterator)
-                logger.debug(
-                    "is_ready_to_process:failed:via_excl: {} - {} > {} {}:{}".format(
-                        get_data_for_log(p_n_node), prev_node.get_name(), node.__class__, node.get_name(), node.instance
-                    )
-                )
-
-            else:
-                logger.debug(
-                    "is_ready_to_process:failed: {} -> {} {}:{}".format(
-                        get_data_for_log(prev_node), node.__class__, node.get_name(), node.instance
-                    )
+        if isinstance(prev_node, TriccNodeExclusive):
+            iterator = iter(prev_node.prev_nodes)
+            p_n_node = next(iterator)
+            logger.debug(
+                "is_ready_to_process:failed:via_excl: {} - {} > {} {}:{}".format(
+                    get_data_for_log(p_n_node), prev_node.get_name(), node.__class__, node.get_name(), node.instance
                 )
+            )
 
+        else:
             logger.debug(
-                "prev node node {}:{} for node {} not in processed".format(
-                    prev_node.__class__, prev_node.get_name(), node.get_name()
+                "is_ready_to_process:failed: {} -> {} {}:{}".format(
+                    get_data_for_log(prev_node), node.__class__, node.get_name(), node.instance
                 )
             )
+
+        logger.debug(
+            "prev node node {}:{} for node {} not in processed".format(
+                prev_node.__class__, prev_node.get_name(), node.get_name()
+            )
+        )
         return False
     return True
 
@@ -1767,36 +1732,28 @@ def replace_next_node(prev_node, next_node, old_node):
 
 
 # Priority constants
-SAME_GROUP_PRIORITY = 70
-PARENT_GROUP_PRIORITY = 60
-ACTIVE_ACTIVITY_PRIORITY = 50
-NON_START_ACTIVITY_PRIORITY = 40
-ACTIVE_ACTIVITY_LOWER_PRIORITY = 30
-FLOW_CALCULATE_NODE_PRIORITY_TOP_UP = 3
-RHOMBUS_PRIORITY_TO_UP = 3
-
-    
+SAME_GROUP_PRIORITY = 7000
+PARENT_GROUP_PRIORITY = 6000
+ACTIVE_ACTIVITY_PRIORITY = 5000
+NON_START_ACTIVITY_PRIORITY = 4000
+ACTIVE_ACTIVITY_LOWER_PRIORITY = 3000
+RHOMBUS_PRIORITY = 1000
+DEFAULT_PRIORITY = 2000
+
+
 def reorder_node_list(node_list, group, processed_nodes):
     # Cache active activities for O(1) lookup
     active_activities = {n.activity for n in processed_nodes}
-    MAP_PRIORITIES = {}
-    def get_priority(node):
-        if node.id in MAP_PRIORITIES:
-            return MAP_PRIORITIES[node.id]
-        if isinstance(node, (TriccNodeActivityStart, TriccNodeMainStart)):
-            return get_priority(node.activity)
-        if isinstance(node, (TriccNodeSelectOption)):
-            return get_priority(node.select)
 
+    def get_priority(node):
         # Cache attributes to avoid repeated getattr calls
-        explicit_priority = getattr(node, "priority", None)
-        priority = int(explicit_priority or 0)
+        priority = int(getattr(node, "priority", 0) or 0)
         node_group = getattr(node, "group", None)
         activity = getattr(node, "activity", None)
 
         # Check for same group
         if group is not None and node_group and node_group.id == group.id:
-            priority += SAME_GROUP_PRIORITY 
+            priority += SAME_GROUP_PRIORITY
         # Check for parent group
         elif hasattr(group, "group") and group.group and node_group and node_group.id == group.group.id:
             priority += PARENT_GROUP_PRIORITY
@@ -1810,21 +1767,11 @@ def reorder_node_list(node_list, group, processed_nodes):
         elif activity and activity in active_activities:
             priority += ACTIVE_ACTIVITY_LOWER_PRIORITY
         # Check for rhombus nodes
-        
-
-        if (
-            issubclass(node.__class__, TriccNodeDisplayCalculateBase) or
-            isinstance(node, TriccNodeEnd)
-        ) and not isinstance(node, TriccNodeActivityEnd) and hasattr(node, 'prev_nodes') and len(node.prev_nodes) > 0:
-            priority += FLOW_CALCULATE_NODE_PRIORITY_TOP_UP
         elif issubclass(node.__class__, TriccRhombusMixIn):
-            priority += RHOMBUS_PRIORITY_TO_UP
+            priority += RHOMBUS_PRIORITY
+        else:
+            priority += DEFAULT_PRIORITY
 
-        if node.prev_nodes and not explicit_priority and not isinstance(node, TriccNodeMainStart):
-            priority = max(priority, *[get_priority(p) for p in node.prev_nodes])
-        
-        MAP_PRIORITIES[node.id] = priority
-        
         return priority
 
     # Sort in place, highest priority first
@@ -2020,7 +1967,7 @@ def get_prev_instance_skip_expression(node, processed_nodes, process, expression
 
 # end def
 def get_process_skip_expression(node, processed_nodes, process, expression=None):
-    list_ends = [x for x in processed_nodes if isinstance(x, TriccNodeEnd)]
+    list_ends = OrderedSet(filter(lambda x: issubclass(x.__class__, TriccNodeEnd), processed_nodes))
     if list_ends:
         end_expressions = []
         f_end_expression = get_end_expression(list_ends)
@@ -2029,11 +1976,8 @@ def get_process_skip_expression(node, processed_nodes, process, expression=None)
         b_end_expression = get_end_expression(list_ends, "pause")
         if b_end_expression:
             end_expressions.append(b_end_expression)
-        process_index = None
-        if process and process[0] in PROCESSES:
-            process_index = PROCESSES.index(process[0])
-        if process_index is not None:
-            for p in PROCESSES[process_index + 1:]:
+        if process[0] in PROCESSES:
+            for p in PROCESSES[PROCESSES.index(process[0]) + 1:]:
                 p_end_expression = get_end_expression(list_ends, p)
                 if p_end_expression:
                     end_expressions.append(p_end_expression)
@@ -2080,7 +2024,7 @@ def get_accept_diagnostic_node(code, display, severity, priority, activity):
     return node
 
 
-def get_diagnostic_node(code, display, severity, priority, activity, option):
+def get_diagnostic_node(code, display, severity, priority, activity):
     node = TriccNodeCalculate(
         id=generate_id("final." + code),
         name="final." + code,
@@ -2091,7 +2035,7 @@ def get_diagnostic_node(code, display, severity, priority, activity, option):
         expression_reference=or_join(
             [
                 TriccOperation(TriccOperator.ISTRUE, [TriccReference("pre_final." + code)]),
-                TriccOperation(TriccOperator.SELECTED, [TriccReference("tricc.manual.diag"), TriccStatic(option)]),
+                TriccOperation(TriccOperator.SELECTED, [TriccReference("tricc.manual.diag"), TriccStatic(code)]),
             ]
         ),
     )
@@ -2150,19 +2094,9 @@ def create_determine_diagnosis_activity(diags):
         group=activity,
         required=TriccStatic(False),
     )
-    options = []
     for proposed in diags:
-        option = TriccNodeSelectOption(
-            id=generate_id(proposed.name),
-            name=proposed.name,
-            label=proposed.label,
-            list_name=f.list_name,
-            relevance=proposed.activity.applicability,
-            select=f,
-        )
-        options.append(option)
         d = get_accept_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity)
-        c = get_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity, option)
+        c = get_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity)
         diags_conf.append(d)
         r = TriccNodeRhombus(
             path=start,
@@ -2187,6 +2121,17 @@ def create_determine_diagnosis_activity(diags):
         activity.nodes[wait2.id] = wait2
     # fallback
 
+    options = [
+        TriccNodeSelectOption(
+            id=generate_id(d.name),
+            name=d.name,
+            label=d.label,
+            list_name=f.list_name,
+            relevance=d.activity.applicability,
+            select=f,
+        )
+        for d in diags
+    ]
     f.options = dict(zip(range(0, len(options)), options))
     activity.nodes[f.id] = f
     set_prev_next_node(f, end, edge_only=False)
@@ -2212,9 +2157,7 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
 
     for act_id in prev_activities:
         act_expression_inputs = []
-        none_sequence_defined_prev_node = False
         for prev_node in prev_activities[act_id]:
-            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
@@ -2241,7 +2184,8 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
         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(
+            if act_sub == TriccStatic(True):
+                act_sub = get_node_expression(
                     prev_node.activity,
                     processed_nodes=processed_nodes,
                     get_overall_exp=get_overall_exp,
@@ -2249,25 +2193,6 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
                     negate=False,
                     process=process,
                 )
-            if act_sub == TriccStatic(True):
-                act_sub = act_relevance
-            elif act_relevance != TriccStatic(True) and 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,
-                #     get_overall_exp=get_overall_exp,
-                #     is_prev=True,
-                #     negate=False,
-                #     process=process,
-                # )
-                act_sub = and_join([
-                    TriccOperation(
-                        TriccOperator.ISTRUE,
-                        [prev_node.activity.root]
-                    ),
-                    act_sub
-                ])
             add_sub_expression(expression_inputs, act_sub)
             # avoid void is there is not conditions to avoid looping too much itme
     # expression_inputs = clean_or_list(
@@ -2314,27 +2239,10 @@ def get_count_terms(node, processed_nodes, get_overall_exp, negate=False, proces
         return TriccOperation(TriccOperator.PLUS, [TriccOperation(TriccOperator.CAST_NUMBER, [term]) for term in terms])
 
 
-def get_none_option(node):
-    if hasattr(node, "options"):
-        for opt in node.options.values():
-            if opt.name == "opt_none":
-                return opt
-    return None
-
-
 def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=False, process=None):
-    opt_none = get_none_option(prev_node)
-    if opt_none:
-        if isinstance(opt_none, str):
-            operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(opt_none)])
-        elif issubclass(opt_none.__class__, TriccBaseModel):
-            operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, opt_none])
-        else:
-            logger.critical(f"unexpected none option value {opt_none}")
-    else:
-        operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic("opt_none")])
+    operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic("opt_none")])
     if isinstance(prev_node, TriccNodeSelectYesNo):
-        return TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(prev_node.options[0])])
+        return TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(prev_node.options[0].name)])
     elif issubclass(prev_node.__class__, TriccNodeSelect):
         if negate:
             return
@@ -2384,11 +2292,7 @@ def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=
                 TriccOperator.CAST_NUMBER,
                 [
                     get_node_expression(
-                        prev_node,
-                        processed_nodes=processed_nodes,
-                        get_overall_exp=get_overall_exp,
-                        is_prev=True,
-                        process=process
+                        prev_node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, is_prev=True, process=process
                     )
                 ],
             )
@@ -2579,6 +2483,15 @@ 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
@@ -2641,13 +2554,16 @@ def get_selected_option_expression_single(option_node, negate):
 
 def get_selected_option_expression_multiple(option_node, negate):
 
-    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, TriccStatic(option_node)])
+    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, option_node])
 
     if negate:
-        return and_join([
+        return TriccOperation(
+            operator=TriccOperator.AND,
+            resource=[
                 TriccOperation(operator=TriccOperator.NOT, resource=[selected]),
                 TriccOperation(operator=TriccOperator.ISNOTNULL, resource=[option_node.select]),
-            ])
+            ],
+        )
 
     else:
         return selected
@@ -2668,12 +2584,6 @@ 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)
@@ -2714,26 +2624,24 @@ def generate_base(node, processed_nodes, **kwargs):
             # we don't overright if define in the diagram
             if node.constraint is None:
                 if isinstance(node, TriccNodeSelectMultiple):
-                    none_opt = get_none_option(node)
-                    if none_opt:
-                        node.constraint = or_join(
-                            [
-                                TriccOperation(
-                                    TriccOperator.EQUAL,
-                                    ["$this", TriccStatic(none_opt)],
-                                ),
-                                TriccOperation(
-                                    TriccOperator.NOT,
-                                    [
-                                        TriccOperation(
-                                            TriccOperator.SELECTED,
-                                            ["$this", TriccStatic(none_opt)],
-                                        )
-                                    ],
-                                ),
-                            ]
-                        )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
-                        node.constraint_message = "**None** cannot be selected together with choice."
+                    node.constraint = or_join(
+                        [
+                            TriccOperation(
+                                TriccOperator.EQUAL,
+                                ["$this", TriccStatic("opt_none")],
+                            ),
+                            TriccOperation(
+                                TriccOperator.NOT,
+                                [
+                                    TriccOperation(
+                                        TriccOperator.SELECTED,
+                                        ["$this", TriccStatic("opt_none")],
+                                    )
+                                ],
+                            ),
+                        ]
+                    )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
+                    node.constraint_message = "**None** cannot be selected together with choice."
                 elif node.tricc_type in (
                     TriccNodeType.integer,
                     TriccNodeType.decimal,
@@ -2758,7 +2666,7 @@ def generate_base(node, processed_nodes, **kwargs):
                         )
                         constraints_max = "The maximum value is {0}.".format(node.max)
                     if len(constraints) > 1:
-                        node.constraint = and_join(constraints)
+                        node.constraint = TriccOperation(TriccOperator.AND, constraints)
                         node.constraint_message = (constraints_min + " " + constraints_max).strip()
                     elif len(constraints) == 1:
                         node.constraint = constraints[0]

{tricc_oo-1.6.26.dist-info → tricc_oo-1.7.0.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.26
+Version: 1.7.0.dev1
 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