tricc-oo 1.6.15__tar.gz → 1.6.18__tar.gz

{tricc_oo-1.6.15/tricc_oo.egg-info → tricc_oo-1.6.18}/PKG-INFO

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

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

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tests/test_cql.py

@@ -26,6 +26,15 @@ class TestCql(unittest.TestCase):
         )
         self.assertEqual(str(dg_operation), str(dg_expected))
 
+    def test_diagnosis_list(self):
+        if_cql = 'DiagnosisList("final.TRIAGE_YELLOW", "triage_RED")'
+        dg_operation = transform_cql_to_operation(if_cql)
+        dg_expected = TriccOperation(
+            operator=TriccOperator.DIAGNOSIS_LIST,
+            reference=[TriccReference(value="final.TRIAGE_YELLOW"), TriccReference(value="triage_RED")],
+        )
+        self.assertEqual(str(dg_operation), str(dg_expected))
+
     def test_implied_concat(self):
         if_cql = "'A' & \"B\" & 'C'"
         cc_operation = transform_cql_to_operation(if_cql)

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/converters/cql_to_operation.py

@@ -37,6 +37,7 @@ FUNCTION_MAP = {
     "HasQualifier": TriccOperator.HAS_QUALIFIER,
     "DateTimeToDecimal": TriccOperator.DATETIME_TO_DECIMAL,
     "Count": TriccOperator.COUNT,
+    "DiagnosisList": TriccOperator.DIAGNOSIS_LIST,
 }
 # TODO
 # Min

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/converters/xml_to_tricc.py

@@ -636,23 +636,23 @@ def enrich_node(diagram, media_path, edge, node, activity, help_before=False):
         # get node and process type
         type, message = get_message(diagram, edge.source_external_id)
         if type is not None:
-            if type == "help":
-                help = TriccNodeMoreInfo(
-                    id=generate_id(),
-                    name=f"{node.name}.more_info",
-                    label=message,
-                    parent=node,
-                    group=node.group,
-                    activity=node.activity,
-                    required=None,
-                )
-                # node.help = message
-                if help_before:
-                    inject_node_before(help, node, activity)
-                else:
-                    set_prev_next_node(node, help, edge_only=True, activity=activity)
-                    activity.nodes[help.id] = help
-                return help, None
+            # if type == "help":
+            #     help = TriccNodeMoreInfo(
+            #         id=generate_id(),
+            #         name=f"{node.name}.more_info",
+            #         label=message,
+            #         parent=node,
+            #         group=node.group,
+            #         activity=node.activity,
+            #         required=None,
+            #     )
+            #     # node.help = message
+            #     if help_before:
+            #         inject_node_before(help, node, activity)
+            #     else:
+            #         set_prev_next_node(node, help, edge_only=True, activity=activity)
+            #         activity.nodes[help.id] = help
+            #     return help, None
 
             if type in (TriccNodeType.start, TriccNodeType.activity_start):
                 return True

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/models/base.py

@@ -377,6 +377,7 @@ class TriccOperator(StrEnum):
     PARENTHESIS = "parenthesis"
     CONCATENATE = "concatenate"
     DATETIME_TO_DECIMAL = "datetime_to_decimal"
+    DIAGNOSIS_LIST = "diagnosis_list"
 
 
 RETURNS_BOOLEAN = [
@@ -423,6 +424,8 @@ RETURNS_NUMBER = [
 
 RETURNS_DATE = [TriccOperator.CAST_DATE]
 
+RETURNS_STRING = [TriccOperator.DIAGNOSIS_LIST]
+
 OPERATION_LIST = {
     ">=": TriccOperator.MORE_OR_EQUAL,
     "<=": TriccOperator.LESS_OR_EQUAL,
@@ -480,6 +483,8 @@ class TriccOperation(BaseModel):
             return "number"
         elif self.operator in RETURNS_DATE:
             return "date"
+        elif self.operator in RETURNS_STRING:
+            return "string"
         elif self.operator == TriccOperator.CONCATENATE:
             return "string"
         elif self.operator == TriccOperator.PARENTHESIS:

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/serializers/xls_form.py

@@ -432,7 +432,7 @@ def get_attr_if_exists(strategy, node, column, map_array):
         return ""
 
 
-def get_more_info_select(strategy, node):
+def get_more_info_select(strategy, base_name, relevance):
     values = []
     for column in SURVEY_MAP:
         if column == "type":
@@ -440,28 +440,30 @@ def get_more_info_select(strategy, node):
         elif column == "label":
             values.append(strategy.get_empty_label())
         elif column == "name":
-            values.append(get_export_name(node) + "_optin")
-        elif column == "hint":
-            print(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
-            values.append(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
+            values.append(base_name + "_optin")
         elif column == "relevance":
-            values.append(get_xfrom_trad(strategy, node.parent, column, SURVEY_MAP))
+            values.append(relevance)
         else:
             values.append(get_xfrom_trad(strategy, None, column, SURVEY_MAP))
     return values
 
 
-def get_more_info_message(strategy, node):
+def get_more_info_message(strategy, base_name, message):
     values = []
     for column in SURVEY_MAP:
         if column == "type":
             values.append("note")
+        elif column == "name":
+            values.append(base_name)
         elif column == "relevance":
-            values.append(f"${{{get_export_name(node)}_optin}} = 1")
-        elif column.startswith("hint"):
-            values.append(langs.get_trads("", trad=None))
+            values.append(f"${{{base_name}_optin}} = 1")
+        elif column.startswith("label"):
+            arr = column.split("::")
+            column = arr[0]
+            trad = arr[1] if len(arr) == 2 else None
+            values.append(langs.get_trads(message, trad=trad))
         else:
-            values.append(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
+            values.append(get_xfrom_trad(strategy, None, column, SURVEY_MAP, clean_html=True))
     return values
 
 
@@ -482,6 +484,13 @@ def get_more_info_choice(strategy):
     return values
 
 
+def inject_more_info(strategy, base_name, relevance, message, df_survey, df_choice):
+    df_survey.loc[len(df_survey)] = get_more_info_select(strategy, base_name, relevance)
+    df_survey.loc[len(df_survey)] = get_more_info_message(strategy, base_name, message)
+    if len(df_choice[(df_choice["list_name"] == "more_info")]) == 0:
+        df_choice.loc[len(df_choice)] = get_more_info_choice(strategy)
+
+
 def generate_xls_form_export(
     strategy,
     node,
@@ -492,6 +501,7 @@ def generate_xls_form_export(
     df_calculate,
     cur_group,
     calculates,
+    help_before=False,
     **kwargs,
 ):
     # check that all prev nodes were processed
@@ -503,6 +513,15 @@ def generate_xls_form_export(
         codesystems=kwargs.get("codesystems", None),
     ):
         if node not in processed_nodes:
+            if help_before and getattr(node, 'help', None):
+                base_name=f"{get_export_name(node)}_more_info"
+                inject_more_info(
+                    strategy,
+                    base_name,
+                    get_xfrom_trad(strategy, node, "relevance", SURVEY_MAP),
+                    node.help,
+                    df_survey,
+                    df_choice)
             add_calculate(calculates, node)
             if node.group != cur_group and not isinstance(node, TriccNodeSelectOption):
                 return False
@@ -530,10 +549,14 @@ def generate_xls_form_export(
                     ):
                         df_choice.loc[len(df_choice)] = values
                 elif isinstance(node, TriccNodeMoreInfo):
-                    df_survey.loc[len(df_survey)] = get_more_info_select(strategy, node)
-                    df_survey.loc[len(df_survey)] = get_more_info_message(strategy, node)
-                    if len(df_choice[(df_choice["list_name"] == "more_info")]) == 0:
-                        df_choice.loc[len(df_choice)] = get_more_info_choice(strategy)
+                    inject_more_info(
+                        strategy,
+                        get_export_name(node),
+                        get_xfrom_trad(strategy, node.parent, "relevance", SURVEY_MAP),
+                        node.label,
+                        df_survey,
+                        df_choice
+                    )
                 elif node.tricc_type in ODK_TRICC_TYPE_MAP and ODK_TRICC_TYPE_MAP[node.tricc_type] is not None:
                     if ODK_TRICC_TYPE_MAP[node.tricc_type] == "calculate":
                         values = []
@@ -560,6 +583,16 @@ def generate_xls_form_export(
                         logger.warning("node {} have an unmapped type {}".format(node.get_name(), node.tricc_type))
                 else:
                     logger.warning("node {} have an unsupported type {}".format(node.get_name(), node.tricc_type))
+            if not help_before and getattr(node, 'help', None):
+                base_name=f"{get_export_name(node)}_more_info"
+                inject_more_info(
+                    strategy,
+                    base_name,
+                    get_xfrom_trad(strategy, node, "relevance", SURVEY_MAP),
+                    node.help,
+                    df_survey,
+                    df_choice
+                )
             # continue walk °
             return True
     return False

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/strategies/output/xls_form.py

@@ -694,6 +694,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
     # @param left part
     # @param right part
     def generate_xls_form_calculate(self, node, processed_nodes, stashed_nodes, calculates, **kwargs):
+        self.codesystems = kwargs.get("codesystems", {})
         if is_ready_to_process(node, processed_nodes, strict=False) and process_reference(
             node,
             processed_nodes,
@@ -749,6 +750,36 @@ class XLSFormStrategy(BaseOutPutStrategy):
     def tricc_operation_concatenate(self, ref_expressions):
         return f"concat({','.join(map(str, ref_expressions))})"
 
+    def tricc_operation_diagnosis_list(self, ref_expressions):
+        from tricc_oo.converters.datadictionnary import lookup_codesystems_code
+        parts = []
+        for expr in ref_expressions:
+            if isinstance(expr, str):
+                # expr is the variable reference like "final.TRIAGE_YELLOW" or "${var}"
+                if expr.startswith("${") and expr.endswith("}"):
+                    var_path = expr[2:-1]
+                else:
+                    var_path = expr
+                # Handle final. prefix
+                code = var_path[6:] if var_path.startswith("final.") else var_path
+                concept = lookup_codesystems_code(self.codesystems, code)
+                if concept:
+                    display = concept.get("display", code)
+                else:
+                    logger.warning(f"Diagnosis code '{code}' not found in codesystems")
+                    display = code
+                if expr.startswith("${"):
+                    condition = f"{expr} = 1"
+                else:
+                    condition = f"${{{expr}}} = 1"
+                # Always include comma after diagnosis name
+                parts.append(f"if({condition}, '{display},', '')")
+            else:
+                logger.warning(f"Unexpected expression type: {type(expr)}, value: {expr}")
+        if parts:
+            return f"concat({','.join(parts)})"
+        return "''"
+
     def validate(self):
         """Validate the generated XLS form using pyxform."""
         try:

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/strategies/output/xlsform_cht.py

@@ -640,6 +640,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         df_settings.to_excel(writer, sheet_name="settings", index=False)
         writer.close()
         # pause
+        logger.info("generating the task and after pause questionnaires")
         ends = []
         for p in self.project.pages.values():
             p_ends = list(

{tricc_oo-1.6.15 → tricc_oo-1.6.18}/tricc_oo/visitors/tricc.py

@@ -56,6 +56,9 @@ from tricc_oo.converters.tricc_to_xls_form import get_list_names, get_export_nam
 logger = logging.getLogger("default")
 ONE_QUESTION_AT_A_TIME = False
 
+# Track the last group that was reordered to avoid unnecessary reordering
+_last_reordered_group = None
+
 
 def merge_node(from_node, to_node):
     if from_node.activity != to_node.activity:
@@ -973,6 +976,7 @@ def walktrhough_tricc_node_processed_stached(
     warn=False,
     node_path=[],
     process=None,
+    loop_count=0,
     **kwargs,
 ):
     ended_activity = False
@@ -1138,7 +1142,10 @@ def walktrhough_tricc_node_processed_stached(
                     if nn not in stashed_nodes:
                         stashed_nodes.insert_at_top(nn)
         if not recursive:
-            reorder_node_list(stashed_nodes, node.group, processed_nodes)
+            global _last_reordered_group
+            if _last_reordered_group != node.group:
+                reorder_node_list(stashed_nodes, node.group, processed_nodes)
+                _last_reordered_group = node.group
 
     else:
         if prev_process and process and prev_process != process[0]:
@@ -1285,7 +1292,7 @@ def stashed_node_func(node, callback, recursive=False, **kwargs):
 
 
 # check if the all the prev nodes are processed
-def is_ready_to_process(in_node, processed_nodes, strict=True, local=False):
+def is_ready_to_process(in_node, processed_nodes, strict=True, local=False, loop_count=0):
     if isinstance(in_node, TriccNodeSelectOption):
         node = in_node.select
     elif isinstance(in_node, (TriccNodeActivityStart, TriccNodeMainStart)):
@@ -1296,36 +1303,38 @@ def is_ready_to_process(in_node, processed_nodes, strict=True, local=False):
     if hasattr(node, "prev_nodes"):
         # ensure the  previous node of the select are processed, not the option prev nodes
         for prev_node in node.prev_nodes:
-            if is_prev_processed(prev_node, node, processed_nodes, local) is False:
+            if is_prev_processed(prev_node, node, processed_nodes, local, loop_count) is False:
                 return False
     return True
 
 
-def is_prev_processed(prev_node, node, processed_nodes, local):
+def is_prev_processed(prev_node, node, processed_nodes, local, loop_count=0):
     if hasattr(prev_node, "select"):
-        return is_prev_processed(prev_node.select, node, processed_nodes, local)
+        return is_prev_processed(prev_node.select, node, processed_nodes, local, loop_count)
     if prev_node not in processed_nodes and (not local):
-        if isinstance(prev_node, TriccNodeExclusive):
-            iterator = iter(prev_node.prev_nodes)
-            p_n_node = next(iterator)
-            logger.debug(
-                "is_ready_to_process:failed:via_excl: {} - {} > {} {}:{}".format(
-                    get_data_for_log(p_n_node), prev_node.get_name(), node.__class__, node.get_name(), node.instance
+        # Only log detailed failures when we suspect dependency loops (loop_count > 5)
+        if loop_count > 5:
+            if isinstance(prev_node, TriccNodeExclusive):
+                iterator = iter(prev_node.prev_nodes)
+                p_n_node = next(iterator)
+                logger.debug(
+                    "is_ready_to_process:failed:via_excl: {} - {} > {} {}:{}".format(
+                        get_data_for_log(p_n_node), prev_node.get_name(), node.__class__, node.get_name(), node.instance
+                    )
                 )
-            )
 
-        else:
-            logger.debug(
-                "is_ready_to_process:failed: {} -> {} {}:{}".format(
-                    get_data_for_log(prev_node), node.__class__, node.get_name(), node.instance
+            else:
+                logger.debug(
+                    "is_ready_to_process:failed: {} -> {} {}:{}".format(
+                        get_data_for_log(prev_node), node.__class__, node.get_name(), node.instance
+                    )
                 )
-            )
 
-        logger.debug(
-            "prev node node {}:{} for node {} not in processed".format(
-                prev_node.__class__, prev_node.get_name(), node.get_name()
+            logger.debug(
+                "prev node node {}:{} for node {} not in processed".format(
+                    prev_node.__class__, prev_node.get_name(), node.get_name()
+                )
             )
-        )
         return False
     return True
 
@@ -1762,7 +1771,8 @@ def reorder_node_list(node_list, group, processed_nodes):
             return get_priority(node.select)
 
         # Cache attributes to avoid repeated getattr calls
-        priority = int(getattr(node, "priority", 0) or 0) 
+        explicit_priority = getattr(node, "priority", None)
+        priority = int(explicit_priority or 0)
         node_group = getattr(node, "group", None)
         activity = getattr(node, "activity", None)
 
@@ -1792,7 +1802,7 @@ def reorder_node_list(node_list, group, processed_nodes):
         elif issubclass(node.__class__, TriccRhombusMixIn):
             priority += RHOMBUS_PRIORITY_TO_UP
 
-        if node.prev_nodes:
+        if node.prev_nodes and not explicit_priority and not isinstance(node, TriccNodeMainStart):
             priority = max(priority, *[get_priority(p) for p in node.prev_nodes])
         
         MAP_PRIORITIES[node.id] = priority

{tricc_oo-1.6.15 → tricc_oo-1.6.18/tricc_oo.egg-info}/PKG-INFO

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