tricc-oo 1.6.7__tar.gz → 1.6.9__tar.gz

{tricc_oo-1.6.7/tricc_oo.egg-info → tricc_oo-1.6.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.7
+Version: 1.6.9
 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.7 → tricc_oo-1.6.9}/pyproject.toml

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

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/converters/tricc_to_xls_form.py

@@ -1,5 +1,5 @@
 import logging
-from tricc_oo.converters.utils import clean_name, clean_str
+from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.tricc import TriccNodeSelectOption, TRICC_TRUE_VALUE, TRICC_FALSE_VALUE, TriccNodeActivity
 from tricc_oo.models.calculate import TriccNodeInput
 from tricc_oo.models.base import TriccNodeBaseModel, TriccStatic, TriccReference
@@ -66,14 +66,13 @@ def get_export_name(node, replace_dots=True):
         return node
     else:
         node.gen_name()
-        if isinstance(node, TriccNodeActivity) and getattr(node, 'instance', 1)>1:
+        if isinstance(node, TriccNodeActivity) and getattr(node, 'instance', 1) > 1:
             node.export_name = clean_name(
                 node.name + INSTANCE_SEPARATOR + str(node.instance),
                 replace_dots=replace_dots,
             )
         elif isinstance(node, TriccNodeSelectOption):
             node.export_name = node.name
-            
         elif node.last is False:
             node.export_name = clean_name(
                 node.name + VERSION_SEPARATOR + str(node.version),

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/converters/xml_to_tricc.py

@@ -7,7 +7,7 @@ import re
 
 from tricc_oo.converters.utils import remove_html, clean_str
 from tricc_oo.converters.cql_to_operation import transform_cql_to_operation
-from tricc_oo.converters.utils import generate_id, get_rand_name
+from tricc_oo.converters.utils import generate_id
 from tricc_oo.models.base import (
     TriccOperator, TriccOperation,
     TriccStatic, TriccReference, TriccNodeType, TriccEdge, OPERATION_LIST
@@ -107,7 +107,7 @@ def create_activity(diagram, media_path, project):
     if root is not None:
         activity = TriccNodeActivity(
             root=root,
-            name=name,  #  start node 'name' is saved in label
+            name=name,  # start node 'name' is saved in label
             id=id,
             external_id=external_id,
             label=label,
@@ -625,6 +625,8 @@ def enrich_node(diagram, media_path, edge, node, activity, help_before=False):
                     name=f"{node.name}.more_info",
                     label=message,
                     parent=node,
+                    group=node.group,
+                    activity=node.activity,
                     required=None,
                 )
                 # node.help = message

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/serializers/xls_form.py

@@ -16,7 +16,7 @@ from tricc_oo.models.calculate import (
     TriccNodeCalculate
 )
 from tricc_oo.models.tricc import (
-    TriccNodeActivity, TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
+    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
     TriccNodeSelectOne,
     TriccNodeSelect,
     TriccNodeMoreInfo,
@@ -39,7 +39,9 @@ logger = logging.getLogger("default")
 langs = SingletonLangClass()
 TRICC_CALC_EXPRESSION = "${{{0}}}>0"
 
-def get_export_group_name(in_node):return f"gcalc_{get_export_name(in_node)}"
+
+def get_export_group_name(in_node): return f"gcalc_{get_export_name(in_node)}"
+
 
 def start_group(
     strategy,
@@ -60,13 +62,12 @@ def start_group(
 
     else:
         groups[name] = 0
-    is_activity = isinstance(cur_group, TriccNodeActivity)
     relevance = relevance and cur_group.relevance is not None and cur_group.relevance != ""
     past_instances = len(getattr(cur_group.base_instance, "instances", []))
-    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances>1)
+    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances > 1)
     calc = None
     if group_calc_required and getattr(cur_group.relevance, 'operator', None) != TriccOperator.ISTRUE:
-        
+
         calc = TriccNodeCalculate(
             id=generate_id(get_export_group_name(name)),
             group=cur_group,
@@ -77,23 +78,22 @@ def start_group(
         if calc not in cur_group.calculates:
             cur_group.calculates.append(calc)
             processed_nodes.add(calc)
-            
+
         cur_group.relevance = TriccOperation(
                 TriccOperator.ISTRUE,
                 [calc]
             )
-    
+
     relevance_expression = cur_group.relevance
     relevance_expression = get_applicability_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_prev_instance_skip_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_process_skip_expression(cur_group, processed_nodes, process, relevance_expression)
 
-
     if not relevance:
         relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
         relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
-    
+
     # group
     values = []
     for column in SURVEY_MAP:
@@ -114,7 +114,7 @@ def start_group(
     df_survey.loc[len(df_survey)] = values
 
     # calc
-    if calc and len(df_calculate[df_calculate["name"] ==  get_export_group_name(name)]) == 0:
+    if calc and len(df_calculate[df_calculate["name"] == get_export_group_name(name)]) == 0:
         calc_values = []
         for column in SURVEY_MAP:
             if column == "type":

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/base_output_strategy.py

@@ -43,6 +43,9 @@ class BaseOutPutStrategy:
 
         self.export(self.project.start_pages, version=version)
 
+        logger.info("validate the output")
+        self.validate()
+
     # walking function
     def process_base(self, start_pages, **kwargs):
         # for each node, check if condition is required issubclass(TriccNodeDisplayModel)
@@ -106,6 +109,10 @@ class BaseOutPutStrategy:
     def export(self, **kwargs):
         pass
 
+    @abc.abstractmethod
+    def validate(self):
+        pass
+
     def tricc_operation_equal(self, ref_expressions):
         # r[0] = r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/dhis2_form.py

@@ -16,7 +16,7 @@ import datetime
 from tricc_oo.strategies.output.base_output_strategy import BaseOutPutStrategy
 from tricc_oo.models.base import (
     not_clean, TriccOperation,
-    TriccStatic, TriccReference
+    TriccStatic, TriccReference, TriccOperator
 )
 from tricc_oo.models.tricc import (
     TriccNodeSelectOption,
@@ -27,6 +27,8 @@ from tricc_oo.models.tricc import (
     TriccNodeActivity,
     TriccNodeSelect,
     TriccNodeSelectYesNo,
+    TriccNodeNote,
+    TriccNodeMoreInfo,
 )
 from tricc_oo.models.calculate import TriccNodeDisplayCalculateBase
 from tricc_oo.models.ordered_set import OrderedSet
@@ -44,7 +46,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def __init__(self, project, output_path):
         super().__init__(project, output_path)
-        form_id = getattr(self.project.start_pages["main"], 'form_id', 'dhis2_program')
+        form_id = getattr(self.project.start_pages["main"].root, 'form_id', 'dhis2_program')
         self.program_metadata = {
             "id": self.generate_id(form_id),
             "name": form_id,
@@ -145,15 +147,16 @@ class DHIS2Strategy(BaseOutPutStrategy):
             raise NotImplementedError(
                 f"This type of operation '{operation.operator}' is not supported in this strategy"
             )
+
     def get_display(self, node):
         if hasattr(node, 'label') and node.label:
-            ret =  node.label
+            ret = node.label
         elif hasattr(node, 'name') and node.name:
             ret = node.name
         else:
             ret = str(node.id)
-        return  ret.replace('\u00a0', ' ').strip()
-    
+        return ret.replace('\u00a0', ' ').strip()
+
     def execute(self):
         version = datetime.datetime.now().strftime("%Y%m%d%H%M")
         logger.info(f"build version: {version}")
@@ -203,6 +206,10 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return False
 
         if node not in processed_nodes:
+            # Skip relevance generation for TriccNodeMoreInfo as they don't create DataElements
+            if isinstance(node, TriccNodeMoreInfo):
+                return True
+
             relevance = None
             if hasattr(node, 'relevance') and node.relevance:
                 relevance = node.relevance
@@ -224,8 +231,10 @@ class DHIS2Strategy(BaseOutPutStrategy):
                             "activity_ref": node,  # Temporary reference to be replaced with section ID
                             "programRule": {"id": rule_id},
                         }
-                    else:
-                        # For regular nodes, use HIDEFIELD action
+                        self.program_rule_actions.append(program_rule_action)
+                    elif not issubclass(node.__class__, TriccNodeCalculateBase) and not isinstance(node, (TriccNodeNote, TriccNodeMoreInfo)):
+                        # For regular nodes that get DataElements, use HIDEFIELD action
+                        # Exclude TriccNodeNote and TriccNodeMoreInfo as they don't get DataElements
                         program_rule_action = {
                             "id": action_id,
                             "programRuleActionType": "HIDEFIELD",
@@ -234,18 +243,45 @@ class DHIS2Strategy(BaseOutPutStrategy):
                             },
                             "programRule": {"id": rule_id}
                         }
-                    self.program_rule_actions.append(program_rule_action)
+                        self.program_rule_actions.append(program_rule_action)
 
                     # Create program rule referencing the action
-                    condition = self.simplify_expression(f"!({relevance_str})")  # Negate for hide when true
+                    condition = self.simplify_expression(f"({relevance_str})==false")  # Negate for hide when true
                     condition = self.simplify_expression(condition)
                     self.program_rules.append({
                         "id": rule_id,
                         "name": f"Hide `{self.get_export_name(node)}` when condition met",
-                        "description": f"Hide `{self.get_display(node)}` based on relevance",
+                        "description": f"Hide `{self.get_display(node)[:128]}` based on relevance",
                         "condition": condition,
                         "programRuleActions": [{"id": action_id}]
                     })
+
+            # Check if field should be mandatory based on 'required' attribute
+            if bool(getattr(node, 'required', False)):
+                # Create program rule for mandatory field using relevance function
+                mandatory_rule_id = self.generate_id(f"rule_{node.get_name()}_mandatory")
+                mandatory_action_id = self.generate_id(f"action_{mandatory_rule_id}")
+
+                mandatory_program_rule_action = {
+                    "id": mandatory_action_id,
+                    "programRuleActionType": "SETMANDATORYFIELD",
+                    "dataElement": {
+                        "id": self.generate_id(self.get_export_name(node))
+                    },
+                    "programRule": {"id": mandatory_rule_id}
+                }
+                self.program_rule_actions.append(mandatory_program_rule_action)
+
+                # Create program rule for mandatory field - use relevance condition if available
+                mandatory_condition = relevance_str if relevance_str and relevance_str != 'false' else "true"
+                self.program_rules.append({
+                    "id": mandatory_rule_id,
+                    "name": f"Make `{self.get_export_name(node)}` mandatory",
+                    "description": f"Set `{self.get_display(node)[:128]}` as mandatory field",
+                    "condition": mandatory_condition,
+                    "programRuleActions": [{"id": mandatory_action_id}]
+                })
+
         return True
 
     def generate_data_element(self, node):
@@ -273,13 +309,12 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName":self.get_display(node),
+                "displayFormName": self.get_display(node),
                 "formName": self.get_display(node),
                 "valueType": value_type,
                 "domainType": "TRACKER",
                 "aggregationType": "NONE"
             }
-            
             if issubclass(node.__class__, TriccNodeSelect) and not isinstance(node, TriccNodeSelectYesNo):
                 data_element["optionSetValue"] = True
 
@@ -512,8 +547,16 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return False
 
         if node not in processed_nodes:
+            logger.debug(f"generate_export processing node: {node.get_name()} type: {type(node)}")
+            # Special handling for TriccNodeNote - transform into section description
+            if isinstance(node, TriccNodeNote):
+                logger.info(f"Found TriccNodeNote: {node.get_name()}")
+                self.handle_note_as_section_description(node, processed_nodes, **kwargs)
+            elif isinstance(node, TriccNodeMoreInfo):
+                logger.info(f"Found TriccNodeMoreInfo: {node.get_name()}")
+                self.handle_note_as_section_description(node, processed_nodes, **kwargs)
             # Skip creating data elements for calculate nodes - they should only be program rule variables
-            if not issubclass(node.__class__, TriccNodeCalculateBase):
+            elif not issubclass(node.__class__, TriccNodeCalculateBase):
                 data_element = self.generate_data_element(node)
                 if data_element:
                     # Add to program stage
@@ -522,7 +565,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                         psde = {
                             "id": psde_id,
                             "dataElement": {"id": data_element["id"]},
-                            "compulsory": bool(getattr(node, 'required', False))
+                            "compulsory": False
                         }
                         self.program_metadata["programStages"][-1]["programStageDataElements"].append(psde)
 
@@ -532,6 +575,115 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
         return True
 
+    def handle_note_as_section_description(self, node, processed_nodes, **kwargs):
+        """Transform TriccNodeNote into section description and create hide logic with section duplication"""
+        logger.info(f"Processing note {node.get_name()} for section description")
+        if not self.current_section or self.current_section not in self.sections:
+            logger.warning(f"No current section found for note {node.get_name()}")
+            return
+
+        # 1. Duplicate the previous section with incremented ID (like XLS form group numbering)
+        original_section = self.sections[self.current_section]
+        section_name = f"{original_section['name']}_{node.name}"
+        duplicated_section_id = self.generate_id(section_name)
+        duplicated_section = {
+            "id": duplicated_section_id,
+            "name": section_name,  # Use incremented naming pattern
+            "sortOrder": len(self.sections),
+            "programStage": {"id": self.program_metadata["programStages"][-1]["id"]},
+            "dataElements": original_section.get("dataElements", []).copy(),  # Copy data elements
+            "activity_ref": original_section.get("activity_ref")
+        }
+        self.sections[duplicated_section_id] = duplicated_section
+
+        # Add duplicated section to program stage
+        if self.program_metadata["programStages"]:
+            self.program_metadata["programStages"][-1]["programStageSections"].append({"id": duplicated_section_id})
+
+        logger.info(f"Duplicated section {self.current_section} as {duplicated_section_id}")
+
+        # 2. Create a new section for the note/moreinfo with name and ID from the node
+        note_section_id = self.generate_id(self.get_export_name(node))
+        note_section_name = self.get_export_name(node)
+
+        note_section = {
+            "id": note_section_id,
+            "name": note_section_name,
+            "sortOrder": len(self.sections),
+            "programStage": {"id": self.program_metadata["programStages"][-1]["id"]},
+            "dataElements": [],
+            "activity_ref": original_section.get("activity_ref")  # Same activity reference
+        }
+
+        # Set section description to the note's label
+        if hasattr(node, 'label') and node.label:
+            note_section["description"] = node.label.replace('\u00a0', ' ').strip()
+            logger.info(f"Set note section {note_section_id} description to: {note_section['description']}")
+        elif hasattr(node, 'name') and node.name:
+            note_section["description"] = node.name.replace('\u00a0', ' ').strip()
+            logger.info(f"Set note section {note_section_id} description to: {note_section['description']}")
+        else:
+            note_section["description"] = str(node.id)
+            logger.info(f"Set note section {note_section_id} description to: {note_section['description']}")
+
+        self.sections[note_section_id] = note_section
+
+        # Add note section to program stage
+        if self.program_metadata["programStages"]:
+            self.program_metadata["programStages"][-1]["programStageSections"].append({"id": note_section_id})
+
+        logger.info(f"Created note section {note_section_id} with name '{note_section_name}'")
+
+        # 3. Inject the duplicated section as the new current section
+        self.current_section = duplicated_section_id
+        logger.info(f"Set current section to duplicated section {duplicated_section_id}")
+
+        # Create hide logic for the note section based on combined relevance
+        combined_relevance = None
+
+        # Get parent activity relevance from the original section's activity_ref
+        parent_activity = original_section.get("activity_ref")
+        if parent_activity and hasattr(parent_activity, 'relevance') and parent_activity.relevance:
+            combined_relevance = parent_activity.relevance
+
+        # Combine with note relevance if it exists
+        if hasattr(node, 'relevance') and node.relevance:
+            if combined_relevance:
+                # Combine using AND operation
+                combined_relevance = TriccOperation(
+                    TriccOperator.AND,
+                    [combined_relevance, node.relevance]
+                )
+            else:
+                combined_relevance = node.relevance
+
+        # Create hide logic if there's relevance - applied to the note section
+        if combined_relevance:
+            relevance_str = self.convert_expression_to_string(not_clean(combined_relevance))
+            if relevance_str and relevance_str != 'false':
+                # Create program rule action for hiding the note section
+                rule_id = self.generate_id(f"rule_{node.get_name()}_note_hide_section")
+                action_id = self.generate_id(f"action_{rule_id}")
+
+                program_rule_action = {
+                    "id": action_id,
+                    "programRuleActionType": "HIDESECTION",
+                    "activity_ref": parent_activity,  # Use activity reference like other HIDESECTION actions
+                    "programRule": {"id": rule_id},
+                }
+                self.program_rule_actions.append(program_rule_action)
+
+                # Create program rule referencing the action
+                condition = self.simplify_expression(f"({relevance_str})==false")  # Negate for hide when true
+                condition = self.simplify_expression(condition)
+                self.program_rules.append({
+                    "id": rule_id,
+                    "name": f"Hide note section `{note_section_name}` based on relevance",
+                    "description": f"Hide note section `{self.get_display(node)[:128]}` based on combined relevance",
+                    "condition": condition,
+                    "programRuleActions": [{"id": action_id}]
+                })
+
     def clean_section(self, program_stages_payload):
         """Clean sections by removing empty ones and merging sections with same activity_ref"""
         sections_to_remove = set()
@@ -542,11 +694,11 @@ class DHIS2Strategy(BaseOutPutStrategy):
             section_id = section["id"]
             activity_ref = section.get("activity_ref")
             # Remove empty sections
-            if not section.get("dataElements"):
+            if not section.get("dataElements") and not section.get("description"):
                 sections_to_remove.add(section_id)
 
             # Check for sections with same activity_ref
-            elif activity_ref == prev_activity_ref:
+            elif activity_ref == prev_activity_ref and not section.get("description"):
                 # Merge this section into the existing one
                 existing_section = self.sections[prev_section_id]
 
@@ -645,6 +797,8 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     # Non-activity actions (HIDEFIELD) can be added directly
                     program_rule_actions_payload.append(action)
 
+        # Filter out rules that reference non-existent actions
+        valid_action_ids = {action["id"] for action in program_rule_actions_payload}
         if self.program_rules:
             program_rules_payload = [
                 {
@@ -652,6 +806,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     "program": {"id": self.program_metadata["id"]}
                 }
                 for rule in self.program_rules
+                if all(action_ref["id"] in valid_action_ids for action_ref in rule["programRuleActions"])
             ]
 
         if self.program_rule_variables:
@@ -736,15 +891,15 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeCalculateBase):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeInputModel):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         else:
             raise NotImplementedError(f"This type of node {r.__class__.__name__} is not supported within an operation")

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/fhir_form.py

@@ -97,7 +97,7 @@ class FHIRStrategy(BaseOutPutStrategy):
             "type": self.map_tricc_type_to_fhir(node.tricc_type if hasattr(node, 'tricc_type') else 'text')
         }
         if hasattr(node, 'options') and node.options:
-            item["answerOption"] = [{"valueString": opt.name} for opt in node.options]
+            item["answerOption"] = [{"valueString": opt.name} for opt in node.options.values()]
         self.questionnaires[segment]["item"].append(item)
         return True
 

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/openmrs_form.py

@@ -410,7 +410,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         elif issubclass(r.__class__, TriccNodeInputModel):
             return self.get_export_name(r)
         elif issubclass(r.__class__, TriccNodeSelect):
-            return "(" + self.get_export_name(r) + " ?? [])"       
+            return "(" + self.get_export_name(r) + " ?? [])"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             return self.get_export_name(r)
         else:
@@ -458,7 +458,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         return f"!({ref_expressions[0]})"
 
     def tricc_operation_plus(self, ref_expressions):
-        return "(" + " + ".join(ref_expressions) +")" 
+        return "(" + " + ".join(ref_expressions) + ")"
 
     def tricc_operation_minus(self, ref_expressions):
         if len(ref_expressions) > 1:

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/xls_form.py

@@ -8,6 +8,7 @@ import logging
 import os
 import re
 import pandas as pd
+from pyxform import create_survey_from_xls
 
 from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.base import (
@@ -409,7 +410,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return f"count-selected({self.clean_coalesce(ref_expressions[0])})"
 
     def tricc_operation_multiplied(self, ref_expressions):
-        return "*".join(map(str,ref_expressions))
+        return "*".join(map(str, ref_expressions))
 
     def tricc_operation_divided(self, ref_expressions):
         return f"{ref_expressions[0]} div {ref_expressions[1]}"
@@ -430,7 +431,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             return f"-{ref_expressions[0]}"
 
     def tricc_operation_plus(self, ref_expressions):
-        return " + ".join(map(str,ref_expressions))
+        return " + ".join(map(str, ref_expressions))
 
     def tricc_operation_not(self, ref_expressions):
         return f"not({ref_expressions[0]})"
@@ -474,7 +475,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 return "0"
                 # return f"jr:choice-name({','.join(ref_expressions[1:])})"
             else:
-                return f"{ref_expressions[0]}({','.join(map(str,ref_expressions[1:]))})"
+                return f"{ref_expressions[0]}({','.join(map(str, ref_expressions[1:]))})"
 
     def tricc_operation_istrue(self, ref_expressions):
         if str(BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]).isnumeric():
@@ -747,3 +748,33 @@ class XLSFormStrategy(BaseOutPutStrategy):
 
     def tricc_operation_concatenate(self, ref_expressions):
         return f"concat({','.join(map(str, ref_expressions))})"
+
+    def validate(self):
+        """Validate the generated XLS form using pyxform."""
+        try:
+            # Determine the XLS file path
+            if self.project.start_pages["main"].root.form_id is not None:
+                form_id = str(self.project.start_pages["main"].root.form_id)
+                xls_path = os.path.join(self.output_path, form_id + ".xlsx")
+
+                if not os.path.exists(xls_path):
+                    logger.error(f"XLS file not found: {xls_path}")
+                    return False
+
+                # Validate using pyxform
+                survey = create_survey_from_xls(xls_path)
+                xml_output = survey.to_xml()
+
+                # Check if XML was generated successfully
+                if xml_output and len(xml_output.strip()) > 0:
+                    logger.info("XLSForm validation successful")
+                    return True
+                else:
+                    logger.error("XLSForm validation failed: Empty XML output")
+                    return False
+            else:
+                logger.error("Form ID not found for validation")
+                return False
+        except Exception as e:
+            logger.error(f"XLSForm validation failed: {str(e)}")
+            return False

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/strategies/output/xlsform_cht.py

@@ -2,6 +2,7 @@ import datetime
 import logging
 import os
 import shutil
+import subprocess
 import pandas as pd
 
 from tricc_oo.models.lang import SingletonLangClass
@@ -616,6 +617,9 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         newpath = os.path.join(self.output_path, newfilename)
         media_path = os.path.join(self.output_path, form_id + "-media")
 
+        # Track all generated XLS files for validation
+        generated_files = [newpath]
+
         settings = {
             "form_title": title,
             "form_id": form_id,
@@ -660,6 +664,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 new_form_id = f"{form_id}_{clean_name(e.name)}"
                 newfilename = f"{new_form_id}.xlsx"
                 newpath = os.path.join(self.output_path, newfilename)
+                generated_files.append(newpath)  # Track additional XLS files
                 settings = {
                     "form_title": title,
                     "form_id": f"{new_form_id}",
@@ -708,6 +713,105 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 shutil.move(os.path.join(media_path_tmp, file_name), media_path)
             shutil.rmtree(media_path_tmp)
 
+        return generated_files
+
+    def execute(self):
+        """Override execute to handle multiple output files from CHT strategy."""
+        version = datetime.datetime.now().strftime("%Y%m%d%H%M")
+        logger.info(f"build version: {version}")
+        if "main" in self.project.start_pages:
+            self.process_base(self.project.start_pages, pages=self.project.pages, version=version)
+        else:
+            logger.critical("Main process required")
+
+        logger.info("generate the relevance based on edges")
+
+        # create relevance Expression
+
+        # create calculate Expression
+        self.process_calculate(self.project.start_pages, pages=self.project.pages)
+        logger.info("generate the export format")
+        # create calculate Expression
+        self.process_export(self.project.start_pages, pages=self.project.pages)
+
+        logger.info("print the export")
+
+        # Export returns list of generated files for CHT strategy
+        generated_files = self.export(self.project.start_pages, version=version)
+
+        logger.info("validate the output")
+        self.validate(generated_files)
+
+    def validate(self, generated_files=None):
+        """Validate the generated XLS form(s) using xls2xform-medic."""
+        if generated_files is None:
+            # Fallback for single file validation
+            if self.project.start_pages["main"].root.form_id is not None:
+                form_id = str(self.project.start_pages["main"].root.form_id)
+                generated_files = [os.path.join(self.output_path, form_id + ".xlsx")]
+            else:
+                logger.error("Form ID not found for validation")
+                return False
+
+        # Ensure xls2xform-medic is available
+        medic_tool = self._ensure_xls2xform_medic()
+        if not medic_tool:
+            logger.error("xls2xform-medic tool not available, skipping CHT validation")
+            return False
+
+        all_valid = True
+        for xls_file in generated_files:
+            if not os.path.exists(xls_file):
+                logger.error(f"XLS file not found: {xls_file}")
+                all_valid = False
+                continue
+
+            try:
+                # Run xls2xform-medic validation
+                result = subprocess.run(
+                    [medic_tool, xls_file],
+                    capture_output=True,
+                    text=True,
+                    cwd=self.output_path
+                )
+
+                if result.returncode == 0:
+                    logger.info(f"CHT XLSForm validation successful: {os.path.basename(xls_file)}")
+                else:
+                    logger.error(f"CHT XLSForm validation failed for {os.path.basename(xls_file)}: {result.stderr}")
+                    all_valid = False
+
+            except Exception as e:
+                logger.error(f"CHT XLSForm validation error for {os.path.basename(xls_file)}: {str(e)}")
+                all_valid = False
+
+        return all_valid
+
+    def _ensure_xls2xform_medic(self):
+        """Ensure xls2xform-medic tool is available."""
+        # Check if it's in PATH
+        medic_tool = shutil.which("xls2xform-medic")
+        if medic_tool:
+            return medic_tool
+
+        # Check if we need to download it
+        medic_path = os.path.join(os.path.dirname(__file__), "xls2xform-medic")
+        if os.path.exists(medic_path):
+            return medic_path
+
+        # Try to download from the provided URL
+        try:
+            import urllib.request
+            medic_url = "https://github.com/medic/pyxform/releases/download/v4.0.0-medic/xls2xform-medic"
+            logger.info(f"Downloading xls2xform-medic from {medic_url}")
+            urllib.request.urlretrieve(medic_url, medic_path)
+            # Make executable
+            os.chmod(medic_path, 0o755)
+            return medic_path
+        except Exception as e:
+            logger.error(f"Failed to download xls2xform-medic: {str(e)}")
+            return None
+
     def tricc_operation_zscore(self, ref_expressions):
         y, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return ((Math.pow((y / m), l) - 1) / (s * l));

{tricc_oo-1.6.7 → tricc_oo-1.6.9}/tricc_oo/visitors/tricc.py

@@ -121,7 +121,10 @@ 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):
@@ -173,8 +176,8 @@ def get_version_inheritance(node, last_version, processed_nodes):
                     node.relevance = expression
     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 the previous saved value with the current node value
         calc_id = generate_id(f"save_{node.save}")
         calc = TriccNodeCalculate(
             id=calc_id,
@@ -184,10 +187,10 @@ def get_version_inheritance(node, last_version, processed_nodes):
                 TriccOperator.COALESCE,
                 [TriccReference(node.save), last_version],
             ),
-            reference=[TriccReference(n.name)],
+            reference=[TriccReference(node.name)],
             activity=node.activity,
             group=node.group,
-            label=f"Save calculation for {n.label}",
+            label=f"Save calculation for {node.label}",
             last=True,
         )
         node.activity.nodes[calc.id] = calc
@@ -1737,7 +1740,7 @@ PARENT_GROUP_PRIORITY = 6000
 ACTIVE_ACTIVITY_PRIORITY = 5000
 NON_START_ACTIVITY_PRIORITY = 4000
 ACTIVE_ACTIVITY_LOWER_PRIORITY = 3000
-FLOW_CALCULATE_NODE_PRIORITY = 8000
+FLOW_CALCULATE_NODE_PRIORITY = 6500
 RHOMBUS_PRIORITY = 1000
 DEFAULT_PRIORITY = 2000
 
@@ -1755,6 +1758,11 @@ def reorder_node_list(node_list, group, processed_nodes):
         # Check for same group
         if group is not None and node_group and node_group.id == group.id:
             priority += SAME_GROUP_PRIORITY
+        elif (
+            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
         # 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
@@ -1765,7 +1773,10 @@ def reorder_node_list(node_list, group, processed_nodes):
         elif activity and isinstance(activity.root, TriccNodeActivityStart):
             priority += NON_START_ACTIVITY_PRIORITY
         # Check for display calculate and end nodes with prev_nodes
-        elif (issubclass(node.__class__, TriccNodeDisplayCalculateBase) or isinstance(node, TriccNodeEnd)) and not isinstance(node, TriccNodeActivityEnd) and hasattr(node, 'prev_nodes') and len(node.prev_nodes) > 0:
+        elif (
+            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
         # Check for active activities (lower priority)
         elif activity and activity in active_activities:
@@ -2100,7 +2111,7 @@ def create_determine_diagnosis_activity(diags):
     )
     options = []
     for proposed in diags:
-        option =  TriccNodeSelectOption(
+        option = TriccNodeSelectOption(
             id=generate_id(proposed.name),
             name=proposed.name,
             label=proposed.label,
@@ -2108,6 +2119,7 @@ def create_determine_diagnosis_activity(diags):
             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)
         diags_conf.append(d)
@@ -2134,7 +2146,6 @@ def create_determine_diagnosis_activity(diags):
         activity.nodes[wait2.id] = wait2
     # fallback
 
-    
     f.options = dict(zip(range(0, len(options)), options))
     activity.nodes[f.id] = f
     set_prev_next_node(f, end, edge_only=False)
@@ -2307,7 +2318,11 @@ 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
                     )
                 ],
             )

{tricc_oo-1.6.7 → tricc_oo-1.6.9/tricc_oo.egg-info}/PKG-INFO

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