tricc-oo 1.6.8__py3-none-any.whl → 1.6.10__py3-none-any.whl

tricc_oo/converters/tricc_to_xls_form.py

@@ -36,7 +36,7 @@ def get_export_name(node, replace_dots=True):
     elif isinstance(node, bool):
         return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)] if node else BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
     elif isinstance(node, TriccReference):
-        logger.warning(f"Reference {node.value} use in export, bad serialiuation probable")
+        logger.warning(f"Reference {node.value} use in export, bad serialization probable")
         return str(node.value)
     elif isinstance(node, (str, TriccStatic, TriccNodeSelectOption)):
         if isinstance(node, TriccNodeSelectOption):

tricc_oo/converters/xml_to_tricc.py

@@ -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/serializers/xls_form.py

@@ -64,19 +64,30 @@ def start_group(
         groups[name] = 0
     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 = False and 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,
+            group=cur_group.group,
             activity=cur_group.activity,
             name=get_export_group_name(name),
-            expression=cur_group.relevance
+            expression=cur_group.relevance.copy()
         )
-        if calc not in cur_group.calculates:
-            cur_group.calculates.append(calc)
+
+        if calc not in cur_group.activity.calculates:
+            process_reference(
+                calc,
+                processed_nodes,
+                calculates=kwargs.get('calculates', None),
+                used_calculates=kwargs.get('used_calculates', None),
+                replace_reference=True,
+                warn=False,
+                codesystems=kwargs.get('codesystems', None)
+            )
+            cur_group.activity.calculates.append(calc)
+            cur_group.activity.nodes[calc.id] = calc
             processed_nodes.add(calc)
 
         cur_group.relevance = TriccOperation(
@@ -123,7 +134,7 @@ def start_group(
                 value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(f"number({strategy.get_tricc_operation_expression(calc.expression)}")
+                calc_values.append(f"number({strategy.get_tricc_operation_expression(calc.expression)})")
             elif column == "relevance":
                 calc_values.append("")
             else:

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,
@@ -204,13 +206,17 @@ 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
             if hasattr(node, 'expression') and node.expression:
                 relevance = node.expression
             if relevance:
-                relevance_str = self.convert_expression_to_string(not_clean(relevance))
+                relevance_str = self.convert_expression_to_string(relevance)
                 if relevance_str and relevance_str != 'false':
                     # Create program rule action for hiding/showing based on relevance
                     rule_id = self.generate_id(f"rule_{node.get_name()}_relevance")
@@ -225,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 issubclass(node.__class__, TriccNodeDisplayModel) and not issubclass(node.__class__, TriccNodeCalculateBase) and not isinstance(node, (TriccNodeNote, TriccNodeMoreInfo, TriccNodeSelectOption)):
+                        # 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",
@@ -235,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):
@@ -274,8 +309,8 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName": self.get_display(node),
-                "formName": self.get_display(node),
+                "displayFormName": "More infromation" if isinstance(node, TriccNodeMoreInfo) else self.get_display(node),
+                "formName": "More infromation" if isinstance(node, TriccNodeMoreInfo) else self.get_display(node),
                 "valueType": value_type,
                 "domainType": "TRACKER",
                 "aggregationType": "NONE"
@@ -512,8 +547,36 @@ 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()}")
+                # Create boolean checkbox data element for moreinfo
+                data_element = self.generate_data_element(node)
+                if data_element:
+                    # Add to program stage
+                    if self.program_metadata["programStages"]:
+                        psde_id = self.generate_id(f"psde_{node.name}")
+                        psde = {
+                            "id": psde_id,
+                            "dataElement": {"id": data_element["id"]},
+                            "compulsory": False
+                        }
+                        self.program_metadata["programStages"][-1]["programStageDataElements"].append(psde)
+
+                        # Add data element to current section
+                        if self.current_section and self.current_section in self.sections:
+                            self.sections[self.current_section]["dataElements"].append({"id": data_element["id"]})
+
+                # Handle the note section with checkbox conditioning
+                checkbox_reference = TriccReference(node.name)
+                checkbox_condition = TriccOperation(TriccOperator.ISTRUE, [checkbox_reference])
+                self.handle_note_as_section_description(node, processed_nodes, additional_condition=checkbox_condition, **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 +585,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 +595,136 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
         return True
 
+    def handle_note_as_section_description(self, node, processed_nodes, additional_condition=None, **kwargs):
+        """Transform TriccNodeNote into section description and create hide logic with section duplication
+
+        Args:
+            node: The node to process (TriccNodeNote or TriccNodeMoreInfo)
+            processed_nodes: Set of already processed nodes
+            additional_condition: Optional additional condition to combine with existing relevance
+        """
+        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")
+        }
+
+        # 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.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}")
+
+        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
+
+        # Combine with additional condition if provided
+        if additional_condition:
+            if combined_relevance:
+                # Combine using AND operation
+                combined_relevance = TriccOperation(
+                    TriccOperator.AND,
+                    [combined_relevance, additional_condition]
+                )
+            else:
+                combined_relevance = additional_condition
+
+        # 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)
+                rule_name = f"Hide note section `{note_section_name}` based on relevance"
+                if additional_condition:
+                    rule_name = f"Hide moreinfo section `{note_section_name}` when checkbox false"
+                self.program_rules.append({
+                    "id": rule_id,
+                    "name": rule_name,
+                    "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 +735,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 +838,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 +847,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:
@@ -710,7 +906,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return self.get_tricc_operation_expression(r)
         elif isinstance(r, TriccReference):
             # Use variable name from concept_map
-            node_id = self.concept_map.get(r.value.name, self.get_export_name(r.value))
+            node_id = self.concept_map.get(r.value, self.get_export_name(r.value))
             return f"#{{{node_id}}}"
         elif isinstance(r, TriccStatic):
             if isinstance(r.value, bool):

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/strategies/output/xlsform_cht.py

@@ -3,8 +3,12 @@ import logging
 import os
 import shutil
 import subprocess
+import tempfile
+import zipfile
 import pandas as pd
 
+from pyxform.xls2xform import convert
+
 from tricc_oo.models.lang import SingletonLangClass
 from tricc_oo.models.calculate import TriccNodeEnd
 from tricc_oo.models.tricc import TriccNodeDisplayModel
@@ -740,10 +744,12 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         generated_files = self.export(self.project.start_pages, version=version)
 
         logger.info("validate the output")
-        self.validate(generated_files)
+        if not self.validate(generated_files):
+            logger.error("CHT validation failed - aborting build")
+            exit(1)
 
     def validate(self, generated_files=None):
-        """Validate the generated XLS form(s) using xls2xform-medic."""
+        """Validate the generated XLS form(s) using pyxform conversion and ODK Validate JAR."""
         if generated_files is None:
             # Fallback for single file validation
             if self.project.start_pages["main"].root.form_id is not None:
@@ -753,10 +759,10 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 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")
+        # Ensure ODK Validate JAR is available
+        jar_path = self._ensure_odk_validate_jar()
+        if not jar_path:
+            logger.error("ODK Validate JAR not available, skipping CHT validation")
             return False
 
         all_valid = True
@@ -767,49 +773,82 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 continue
 
             try:
-                # Run xls2xform-medic validation
-                result = subprocess.run(
-                    [medic_tool, xls_file],
-                    capture_output=True,
-                    text=True,
-                    cwd=self.output_path
+                # Convert XLS to XForm using pyxform (without validation)
+                xform_path = xls_file.replace('.xlsx', '.xml')
+                convert_result = convert(
+                    xlsform=xls_file,
+                    validate=False,  # Don't validate during conversion
+                    pretty_print=True
                 )
+                xform_content = convert_result.xform
+
+                # Write XForm to temporary file for validation
+                with tempfile.NamedTemporaryFile(mode='w', suffix='.xml', delete=False) as temp_file:
+                    temp_file.write(xform_content)
+                    temp_xform_path = temp_file.name
+
+                try:
+                    # Run ODK Validate JAR on the XForm
+                    result = subprocess.run(
+                        ["java", "-Djava.awt.headless=true", "-jar", jar_path, temp_xform_path],
+                        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
+                    if result.returncode == 0 or "Cycle detected" in result.stderr:
+                        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
+
+                finally:
+                    # Clean up temporary XForm file
+                    os.unlink(temp_xform_path)
 
             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
+                jar_in_zip = "site-packages/pyxform/validators/odk_validate/bin/ODK_Validate.jar"
+                zip_ref.extract(jar_in_zip, os.path.dirname(__file__))
+
+                # Move to final location
+                extracted_jar = os.path.join(os.path.dirname(__file__), jar_in_zip)
+                shutil.move(extracted_jar, jar_path)
 
-    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
+            logger.info(f"Extracted ODK Validate JAR to {jar_path}")
+            return jar_path
 
-        # 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
+    def _ensure_odk_validate_jar(self):
+        """Ensure ODK Validate JAR is available by extracting from medic zip."""
+        jar_path = os.path.join(os.path.dirname(__file__), "ODK_Validate.jar")
+
+        # Check if JAR already exists
+        if os.path.exists(jar_path):
+            return jar_path
+
+        # Extract JAR from medic zip
+        medic_zip_path = os.path.join(os.path.dirname(__file__), "xls2xform-medic")
+        if not os.path.exists(medic_zip_path):
+            logger.error("xls2xform-medic zip not found, cannot extract ODK Validate JAR")
+            return None
 
-        # 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
+            with zipfile.ZipFile(medic_zip_path, 'r') as zip_ref:
+                # Extract the JAR from the zip
+                jar_in_zip = "site-packages/pyxform/validators/odk_validate/bin/ODK_Validate.jar"
+                zip_ref.extract(jar_in_zip, os.path.dirname(__file__))
+
+                # Move to final location
+                extracted_jar = os.path.join(os.path.dirname(__file__), jar_in_zip)
+                shutil.move(extracted_jar, jar_path)
+
+            logger.info(f"Extracted ODK Validate JAR to {jar_path}")
+            return jar_path
+
         except Exception as e:
-            logger.error(f"Failed to download xls2xform-medic: {str(e)}")
+            logger.error(f"Failed to extract ODK Validate JAR: {str(e)}")
             return None
 
     def tricc_operation_zscore(self, ref_expressions):
@@ -836,7 +875,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[2])
             } ,{
             self.clean_coalesce(ref_expressions[3])
-            }, true)"""
+            }, true"""
 
     def tricc_operation_drug_dosage(self, ref_expressions):
         # drug name

tricc_oo/visitors/tricc.py

@@ -1758,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
@@ -1767,12 +1772,6 @@ def reorder_node_list(node_list, group, processed_nodes):
         # Check for non main activities
         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:
-            priority += FLOW_CALCULATE_NODE_PRIORITY
         # Check for active activities (lower priority)
         elif activity and activity in active_activities:
             priority += ACTIVE_ACTIVITY_LOWER_PRIORITY

{tricc_oo-1.6.8.dist-info → tricc_oo-1.6.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.8
+Version: 1.6.10
 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.8.dist-info → tricc_oo-1.6.10.dist-info}/RECORD

@@ -8,9 +8,9 @@ tricc_oo/converters/codesystem_to_ocl.py,sha256=Fh7Vk73OsxljZKu1k6H9uzYwz334tpQT
 tricc_oo/converters/cql_to_operation.py,sha256=PUyV_YpUY98Ox0H_F_CN3UUf_I-BhFZVOcWWKTtwecM,14492
 tricc_oo/converters/datadictionnary.py,sha256=T2HLCBo4Am1p0kFqSH1r0PqbD8AC2IGuWkbvMvSCru0,3658
 tricc_oo/converters/drawio_type_map.py,sha256=UCPiGs7Lw0bigKScmZUnmOhACBz-FiDq92jHkI7RTSQ,9113
-tricc_oo/converters/tricc_to_xls_form.py,sha256=wsWv4aA0QssY7ry9R7KsuuMzVfovj9fwE3i9AtCum0c,3842
+tricc_oo/converters/tricc_to_xls_form.py,sha256=39hwWgYNitGE-AuKtjUwNLz39tEpwc7nd9gT_gw5wjc,3842
 tricc_oo/converters/utils.py,sha256=JZrtrvvOfXwdkw49pKauzinOcauWwsy-CVcw36TjyLo,1684
-tricc_oo/converters/xml_to_tricc.py,sha256=PEBe8N-JIGJMVX2FO3UVxRcy5GrGsMvgcArEwUXmr6o,39572
+tricc_oo/converters/xml_to_tricc.py,sha256=yqnU5xg1SVoQ8vra0gOvIPwoh80pyTI332y9qJCvcRs,39654
 tricc_oo/converters/cql/cqlLexer.py,sha256=8HArbRphcrpnAG4uogJ2rHv4tc1WLzjN0B1uFeYILAc,49141
 tricc_oo/converters/cql/cqlListener.py,sha256=fA7-8DcS2Q69ckwjdg57-OfFHBxjTZFdoSKrtw7Hffc,57538
 tricc_oo/converters/cql/cqlParser.py,sha256=x3KdrwX9nwENSEJ5Ex7_l5NMnu3kWBO0uLdYu4moTq0,414745
@@ -26,27 +26,27 @@ tricc_oo/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 tricc_oo/parsers/xml.py,sha256=uzkb1y18MHfqVFmZqVh0sKT4cx6u0-NcAT_lV_gHBt8,4208
 tricc_oo/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/serializers/planuml.py,sha256=t57587-6L3aDncpHh58lS77Zft8yxDE9DPtXx2BeUSU,132
-tricc_oo/serializers/xls_form.py,sha256=L0WF774zFt6PbdqncJGeyZzM9NiLq9NY5vO98yGTLhM,22133
+tricc_oo/serializers/xls_form.py,sha256=_sYYVmJkGJeeOr8l_FzRIOuCcGzrxeFc1APXBgNNs08,22585
 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/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/dhis2_form.py,sha256=O5sBcwG_i6Vx3T5-Be4MmE50CsW4obikS3p8MOOJu1o,49317
+tricc_oo/strategies/output/fhir_form.py,sha256=yDDJqdkt4PvSDEy4kmgKM8V_o757CDlE7813atyyDHM,15749
 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=_pNTND7n-55EjRphJ1hSVtRYa-UkXlmwpam2OKQ8o_w,30860
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=X00Lt5MzV8TX14dR4dFI1MqllI5S1e13bKbeysWM9uA,17435
-tricc_oo/strategies/output/xlsform_cht.py,sha256=eKAc6LLDnvdZ5m8a2Vk6eAhvPbUvOfykgYr0ou3an9k,27164
+tricc_oo/strategies/output/xlsform_cht.py,sha256=RXacGiVAib5bF_0ea564YhuJ1ASs20MuMuIeZXiP5-M,29019
 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=8fULbAxKSeEtPyD5TYTaIG8-20Bjg2iZmzxcJM70n18,110295
+tricc_oo/visitors/tricc.py,sha256=9jAVSxFfklJcLzwLvZAV1_sRuD8616HSgOSl8wdqPTE,110227
 tricc_oo/visitors/utils.py,sha256=j83aAq5s5atXi3OC0jc_uJd54a8XrHHmizeeEbWZQJg,421
 tricc_oo/visitors/xform_pd.py,sha256=ryAnI3V9x3eTmJ2LNsUZfvl0_yfCqo6oBgeSu-WPqaE,9613
-tricc_oo-1.6.8.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-tricc_oo-1.6.8.dist-info/METADATA,sha256=g9u0_NdvNT8FFgNB3LQzsUADmGqL1PBB1DPdnCBKVuI,8599
-tricc_oo-1.6.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tricc_oo-1.6.8.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.6.8.dist-info/RECORD,,
+tricc_oo-1.6.10.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+tricc_oo-1.6.10.dist-info/METADATA,sha256=kiJuIi8qGKOf5IP63NtQYJ7ReSJJHrReUl3fuWEJS18,8600
+tricc_oo-1.6.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tricc_oo-1.6.10.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.6.10.dist-info/RECORD,,