tricc-oo 1.6.11__tar.gz → 1.6.13__tar.gz

{tricc_oo-1.6.11/tricc_oo.egg-info → tricc_oo-1.6.13}/PKG-INFO

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

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

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/converters/codesystem_to_ocl.py

@@ -31,16 +31,16 @@ def extract_properties_metadata(fhir_cs: CodeSystem) -> Dict[str, Dict]:
 
             property_types[prop.code] = {
                 "name": prop.code,
-                "datatype": ocl_type,
+                "dataType": ocl_type,
                 "description": prop.description if hasattr(prop, "description") else "",
             }
     return property_types
 
 
 def get_fhir_concept_datatype(concept):
-    datatype = extract_concept_properties(concept, ["datatype"])
+    datatype = extract_concept_properties(concept, ["dataType"])
     if datatype:
-        return datatype["datatype"]
+        return datatype["dataType"]
     else:
         return OclConstants.DATA_TYPE_NONE
 
@@ -84,7 +84,7 @@ def get_attributes_from_concept_properties(concept, property_types: Dict) -> Lis
                 "type": "Attribute",
                 "attribute_type": code,
                 "value": value,
-                "value_type": property_types[code]["datatype"],
+                "value_type": property_types[code]["dataType"],
             }
         )
     return attributes

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/converters/datadictionnary.py

@@ -103,7 +103,7 @@ def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attr
                 # TODO support other type of Codesystem Concept Property Value
                 existing_attributes
                 if p.valueString != v:
-                    logger.warning(f"conflicting value for property {k}: {p.valueString} != {v}")
+                    logger.warning(f"conflicting value for concept `{concept.code}` property ` {k}`: {p.valueString} != {v}")
         if not existing_attributes:
             new_concept.property.append(CodeSystemConceptProperty(code=k, valueString=v))
 

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/converters/drawio_type_map.py

@@ -47,7 +47,7 @@ TYPE_MAP = {
     },
     TriccNodeType.note: {
         "objects": ["UserObject", "object"],
-        "attributes": ["relevance", "priority", "context_type"],
+        "attributes": ["relevance", "priority", "concept_type"],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeNote,
     },
@@ -76,7 +76,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectOne,
@@ -94,7 +94,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectMultiple,
@@ -112,7 +112,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDecimal,
@@ -130,7 +130,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeInteger,
@@ -145,7 +145,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeText,
@@ -160,7 +160,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDate,
@@ -183,7 +183,7 @@ TYPE_MAP = {
             "save",
             "reference",
             "trigger",
-            "context_type",
+            "concept_type",
             "remote_reference",
         ],
         "mandatory_attributes": ["name", "label"],
@@ -217,7 +217,7 @@ TYPE_MAP = {
     },
     TriccNodeType.not_available: {
         "objects": ["UserObject", "object"],
-        "attributes": ["context_type"],
+        "attributes": ["concept_type"],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectNotAvailable,
     },
@@ -233,7 +233,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectYesNo,
@@ -295,7 +295,7 @@ TYPE_MAP = {
     },
     TriccNodeType.input: {
         "objects": ["UserObject", "object"],
-        "attributes": ["save", "reference", "datatype", "context_type"],
+        "attributes": ["save", "reference", "data_type", "concept_type"],
         "mandatory_attributes": ["name", "label"],
         "model": TriccNodeInput,
     },

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/converters/xml_to_tricc.py

@@ -128,7 +128,7 @@ def create_activity(diagram, media_path, project):
         for n in nodes.values():
 
             if (
-                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase))
+                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeInput))
                 and not isinstance(n, (TriccRhombusMixIn, TriccNodeRhombus, TriccNodeDisplayBridge))
                 and not n.name.startswith("label_")  # FIXME
             ):
@@ -139,7 +139,7 @@ def create_activity(diagram, media_path, project):
                         system,
                         n.select.name,
                         n.label,
-                        {"datatype": "Boolean", "contextType": get_context_type(n)},
+                        {"dataType": "Boolean", "conceptType": get_concept_type(n)},
                     )
                 elif not isinstance(n, TriccNodeSelectNotAvailable):
                     add_concept(
@@ -148,8 +148,20 @@ def create_activity(diagram, media_path, project):
                         n.name,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
+                        },
+                    )
+                elif not issubclass(n.__class__, TriccNodeCalculate):
+                    system = n.name.split(".")[0] if "." in n.name else "calculate"
+                    add_concept(
+                        project.code_systems,
+                        system,
+                        n.name,
+                        n.label,
+                        {
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
                 if getattr(n, "save", None):
@@ -160,8 +172,8 @@ def create_activity(diagram, media_path, project):
                         n.save,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
 
@@ -175,7 +187,7 @@ def create_activity(diagram, media_path, project):
         # link back the activity
         activity.root.activity = activity
         manage_dangling_calculate(activity)
-
+        # assign the process
         if activity is not None:
             if activity.root is not None:
                 project.pages[activity.id] = activity
@@ -197,6 +209,7 @@ def create_activity(diagram, media_path, project):
                         )
         if images:
             project.images += images
+        # Assign parent to NotAvailable
         for node in list(
             filter(
                 lambda p_node: isinstance(p_node, TriccNodeSelectNotAvailable),
@@ -477,10 +490,10 @@ def set_additional_attributes(attribute_names, elm, node):
             setattr(node, attributename, attribute)
 
 
-def get_context_type(node):
-    context_type = getattr(node, "context_type", None)
-    if context_type:
-        return context_type
+def get_concept_type(node):
+    concept_type = getattr(node, "concept_type", None)
+    if concept_type:
+        return concept_type
     if isinstance(node, TriccNodeSelectMultiple):
         return "Question"
     elif isinstance(node, TriccNodeSelectOption):
@@ -535,7 +548,7 @@ def get_select_options(diagram, select_node, nodes):
             activity=select_node.activity,
             group=select_node.group,
         )
-        set_additional_attributes(["save", "relevance", "context_type"], elm, option)
+        set_additional_attributes(["save", "relevance", "concept_type"], elm, option)
         load_expressions(option)
         options[i] = option
         nodes[id] = option
@@ -802,9 +815,11 @@ def set_mandatory_attribute(elm, mandatory_attributes, diagram=None):
             id = elm.attrib.get("id")
             attribute_value = _get_name(name, id, diagram_id)
         elif attributes == "list_name":
-            name = elm.attrib.get("name")
-            id = elm.attrib.get("id")
-            attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
+            attribute_value = elm.attrib.get("list_name", None)
+            if not attribute_value:
+                name = elm.attrib.get("name")
+                id = elm.attrib.get("id")
+                attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
         else:
             attribute_value = elm.attrib.get(attributes)
         if attribute_value is None:

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/serializers/xls_form.py

@@ -32,6 +32,7 @@ from tricc_oo.visitors.tricc import (
     get_applicability_expression,
     get_prev_instance_skip_expression,
     get_process_skip_expression,
+    process_operation_reference,
 )
 
 logger = logging.getLogger("default")
@@ -73,7 +74,7 @@ def start_group(
             group=cur_group.group,
             activity=cur_group.activity,
             name=get_export_group_name(name),
-            expression=cur_group.relevance.copy()
+            expression=cur_group.relevance
         )
 
         if calc not in cur_group.activity.calculates:
@@ -103,7 +104,18 @@ def start_group(
     if not relevance:
         relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
-        relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
+        relevance_expression = process_operation_reference(
+            relevance_expression,
+            cur_group,
+            processed_nodes=processed_nodes,
+            calculates=kwargs.get('calculates', None),
+            used_calculates=kwargs.get('used_calculates', None),
+            replace_reference=True,
+            warn=False,
+            codesystems=kwargs.get('codesystems', None),
+        ) or relevance_expression
+        if relevance_expression:
+            relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
 
     # group
     values = []

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/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, TriccOperator
+    TriccStatic, TriccReference
 )
 from tricc_oo.models.tricc import (
     TriccNodeSelectOption,
@@ -27,8 +27,6 @@ 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
@@ -46,7 +44,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def __init__(self, project, output_path):
         super().__init__(project, output_path)
-        form_id = getattr(self.project.start_pages["main"].root, 'form_id', 'dhis2_program')
+        form_id = getattr(self.project.start_pages["main"], 'form_id', 'dhis2_program')
         self.program_metadata = {
             "id": self.generate_id(form_id),
             "name": form_id,
@@ -206,17 +204,13 @@ 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(relevance)
+                relevance_str = self.convert_expression_to_string(not_clean(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")
@@ -231,10 +225,8 @@ class DHIS2Strategy(BaseOutPutStrategy):
                             "activity_ref": node,  # Temporary reference to be replaced with section ID
                             "programRule": {"id": rule_id},
                         }
-                        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
+                    else:
+                        # For regular nodes, use HIDEFIELD action
                         program_rule_action = {
                             "id": action_id,
                             "programRuleActionType": "HIDEFIELD",
@@ -243,45 +235,18 @@ 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})==false")  # Negate for hide when true
+                    condition = self.simplify_expression(f"!({relevance_str})")  # 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)[:128]}` based on relevance",
+                        "description": f"Hide `{self.get_display(node)}` 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):
@@ -309,8 +274,8 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName": "More infromation" if isinstance(node, TriccNodeMoreInfo) else self.get_display(node),
-                "formName": "More infromation" if isinstance(node, TriccNodeMoreInfo) else self.get_display(node),
+                "displayFormName": self.get_display(node),
+                "formName": self.get_display(node),
                 "valueType": value_type,
                 "domainType": "TRACKER",
                 "aggregationType": "NONE"
@@ -547,36 +512,8 @@ 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
-            elif not issubclass(node.__class__, TriccNodeCalculateBase):
+            if not issubclass(node.__class__, TriccNodeCalculateBase):
                 data_element = self.generate_data_element(node)
                 if data_element:
                     # Add to program stage
@@ -585,7 +522,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                         psde = {
                             "id": psde_id,
                             "dataElement": {"id": data_element["id"]},
-                            "compulsory": False
+                            "compulsory": bool(getattr(node, 'required', False))
                         }
                         self.program_metadata["programStages"][-1]["programStageDataElements"].append(psde)
 
@@ -595,136 +532,6 @@ 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()
@@ -735,11 +542,11 @@ class DHIS2Strategy(BaseOutPutStrategy):
             section_id = section["id"]
             activity_ref = section.get("activity_ref")
             # Remove empty sections
-            if not section.get("dataElements") and not section.get("description"):
+            if not section.get("dataElements"):
                 sections_to_remove.add(section_id)
 
             # Check for sections with same activity_ref
-            elif activity_ref == prev_activity_ref and not section.get("description"):
+            elif activity_ref == prev_activity_ref:
                 # Merge this section into the existing one
                 existing_section = self.sections[prev_section_id]
 
@@ -838,8 +645,6 @@ 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 = [
                 {
@@ -847,7 +652,6 @@ 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:
@@ -906,7 +710,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, self.get_export_name(r.value))
+            node_id = self.concept_map.get(r.value.name, self.get_export_name(r.value))
             return f"#{{{node_id}}}"
         elif isinstance(r, TriccStatic):
             if isinstance(r.value, bool):

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/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.values()]
+            item["answerOption"] = [{"valueString": opt.name} for opt in node.options]
         self.questionnaires[segment]["item"].append(item)
         return True
 

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/strategies/output/xlsform_cht.py

@@ -821,34 +821,22 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             return jar_path
 
     def _ensure_odk_validate_jar(self):
-        """Ensure ODK Validate JAR is available by extracting from medic zip."""
+        """Ensure ODK Validate JAR is available by downloading from GitHub releases."""
         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
-
+        # Download JAR from GitHub releases
+        jar_url = "https://github.com/getodk/validate/releases/download/v1.20.0/ODK-Validate-v1.20.0.jar"
         try:
-            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}")
+            import urllib.request
+            urllib.request.urlretrieve(jar_url, jar_path)
+            logger.info(f"Downloaded ODK Validate JAR to {jar_path}")
             return jar_path
-
         except Exception as e:
-            logger.error(f"Failed to extract ODK Validate JAR: {str(e)}")
+            logger.error(f"Failed to download ODK Validate JAR: {str(e)}")
             return None
 
     def tricc_operation_zscore(self, ref_expressions):

{tricc_oo-1.6.11 → tricc_oo-1.6.13}/tricc_oo/visitors/tricc.py

@@ -185,9 +185,9 @@ def get_version_inheritance(node, last_version, processed_nodes):
             path_len=node.path_len + 1,
             expression_reference=TriccOperation(
                 TriccOperator.COALESCE,
-                [TriccReference(node.save), last_version],
+                [node, last_version],
             ),
-            reference=[TriccReference(node.name)],
+            reference=[node, last_version],
             activity=node.activity,
             group=node.group,
             label=f"Save calculation for {node.label}",
@@ -805,7 +805,7 @@ def process_operation_reference(
     operation,
     node,
     processed_nodes,
-    calculates,
+    calculates=None,
     used_calculates=None,
     replace_reference=False,
     warn=False,
@@ -1740,16 +1740,17 @@ PARENT_GROUP_PRIORITY = 6000
 ACTIVE_ACTIVITY_PRIORITY = 5000
 NON_START_ACTIVITY_PRIORITY = 4000
 ACTIVE_ACTIVITY_LOWER_PRIORITY = 3000
-FLOW_CALCULATE_NODE_PRIORITY = 6500
-RHOMBUS_PRIORITY = 1000
-DEFAULT_PRIORITY = 2000
-
+FLOW_CALCULATE_NODE_PRIORITY_TOP_UP = 50
+RHOMBUS_PRIORITY_TO_UP = 50
 
+    
 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]
         # Cache attributes to avoid repeated getattr calls
         priority = int(getattr(node, "priority", 0) or 0)
         node_group = getattr(node, "group", None)
@@ -1757,12 +1758,7 @@ 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
+            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
@@ -1776,11 +1772,21 @@ 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
-        else:
-            priority += DEFAULT_PRIORITY
+            priority += RHOMBUS_PRIORITY_TO_UP
 
+        if node.prev_nodes:
+            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
@@ -2258,7 +2264,12 @@ def get_none_option(node):
 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:
-        operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(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")])
     if isinstance(prev_node, TriccNodeSelectYesNo):

{tricc_oo-1.6.11 → tricc_oo-1.6.13/tricc_oo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.11
+Version: 1.6.13
 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.11 → tricc_oo-1.6.13}/tricc_oo.egg-info/SOURCES.txt

@@ -2,7 +2,6 @@ LICENSE
 README.md
 pyproject.toml
 tests/build.py
-tests/test_build.py
 tests/test_cql.py
 tests/to_ocl.py
 tricc_oo/__init__.py

tricc_oo-1.6.11/tests/test_build.py

@@ -1,260 +0,0 @@
-import unittest
-import subprocess
-import sys
-import os
-import tempfile
-import shutil
-from pathlib import Path
-import pandas as pd
-from pyxform import create_survey_from_xls
-
-
-class TestBuildScript(unittest.TestCase):
-    """Test cases for the build.py script with different argument combinations."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_data_dir = Path(__file__).parent / "data"
-        self.test_output_dir = Path(__file__).parent / "output"
-        self.demo_file = self.test_data_dir / "demo.drawio"
-
-        # Ensure test data exists
-        self.assertTrue(self.demo_file.exists(), f"Test data file {self.demo_file} does not exist")
-
-    def run_build_script(self, args):
-        """Helper method to run build.py with given arguments."""
-        cmd = [sys.executable, str(Path(__file__).parent / "build.py")] + args
-        result = subprocess.run(cmd, capture_output=True, text=True, cwd=Path(__file__).parent.parent)
-        return result
-
-    def test_basic_build_with_demo_file(self):
-        """Test basic build with demo.drawio file."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_directory_input(self):
-        """Test build with directory containing drawio files."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.test_data_dir),
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_xlsform_strategy(self):
-        """Test build with XLSFormStrategy (default)."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_html_strategy(self):
-        """Test build with HTMLStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "HTMLStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_fhir_strategy(self):
-        """Test build with FHIRStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "FHIRStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_dhis2_strategy(self):
-        """Test build with DHIS2Strategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "DHIS2Strategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_openmrs_strategy(self):
-        """Test build with OpenMRSStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "OpenMRSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cht_strategy(self):
-        """Test build with XLSFormCHTStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCHTStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cht_hf_strategy(self):
-        """Test build with XLSFormCHTHFStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCHTHFStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cdss_strategy(self):
-        """Test build with XLSFormCDSSStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCDSSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    # def test_build_with_spice_strategy(self):
-    #     """Test build with SpiceStrategy."""
-    #     with tempfile.TemporaryDirectory() as temp_dir:
-    #         args = [
-    #             "-i", str(self.demo_file),
-    #             "-o", temp_dir,
-    #             "-O", "SpiceStrategy",
-    #             "-l", "i"
-    #         ]
-    #         result = self.run_build_script(args)
-    #         self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_debug_level(self):
-        """Test build with debug logging level."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-l", "d"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_trad_option(self):
-        """Test build with translation option."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-t",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_form_id(self):
-        """Test build with custom form ID."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-d", "test_form_123",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_missing_input(self):
-        """Test build with missing input file."""
-        args = ["-o", "/tmp/test_output"]
-        result = self.run_build_script(args)
-        self.assertNotEqual(result.returncode, 0, "Build should fail with missing input")
-
-    def test_build_invalid_input_file(self):
-        """Test build with invalid input file."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", "/nonexistent/file.drawio",
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertNotEqual(result.returncode, 0, "Build should fail with invalid input file")
-
-    def validate_xls_form(self, xls_path):
-        """Helper method to validate XLS form using ODK libraries."""
-        try:
-            # Convert XLS to XML using pyxform
-            survey = create_survey_from_xls(xls_path)
-            xml_output = survey.to_xml()
-
-            # Basic validation - check if XML was generated successfully
-            # In a real scenario, you might want to use odk_validate command line tool
-            if xml_output and len(xml_output.strip()) > 0:
-                return True, "Validation successful"
-            else:
-                return False, "Empty XML output"
-        except Exception as e:
-            return False, str(e)
-
-    def test_xlsform_strategy_validation(self):
-        """Test XLSFormStrategy output validation with ODK libraries."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-            # Check if XLS file was created
-            self.assertTrue(xls_output.exists(), f"XLS file {xls_output} was not created")
-
-    def test_xlsform_cdss_strategy_validation(self):
-        """Test XLSFormCDSSStrategy output validation with ODK libraries."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCDSSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-
-
-if __name__ == "__main__":
-    unittest.main()