tricc-oo 1.6.5.dev1__tar.gz → 1.6.6__tar.gz

{tricc_oo-1.6.5.dev1/tricc_oo.egg-info → tricc_oo-1.6.6}/PKG-INFO

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

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

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/converters/tricc_to_xls_form.py

@@ -43,6 +43,8 @@ def get_export_name(node, replace_dots=True):
             value = node.name
         elif isinstance(node, TriccStatic):
             value = node.value
+            if isinstance(value, TriccNodeSelectOption):
+                value = value.name
         else:
             value = node
         if isinstance(value, bool):  # or r.value in ('true', 'false')

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/models/base.py

@@ -11,7 +11,7 @@ from tricc_oo.models.ordered_set import OrderedSet
 
 logger = logging.getLogger("default")
 
-Expression = Annotated[str, StringConstraints(pattern=r"^[^\\/\:]+$")]
+Expression = Annotated[str, StringConstraints(pattern=r".+")]
 
 triccId = Annotated[str, StringConstraints(pattern=r"^[^\\/\: ]+$")]
 
@@ -274,7 +274,7 @@ class TriccNodeBaseModel(TriccBaseModel):
 
 
 class TriccStatic(BaseModel):
-    value: Union[str, float, int, bool]
+    value: Union[str, float, int, bool, TriccNodeBaseModel]
 
     def __init__(self, value):
         super().__init__(value=value)

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/serializers/xls_form.py

@@ -123,7 +123,7 @@ def start_group(
                 value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(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:
@@ -415,7 +415,7 @@ def get_more_info_select(strategy, node):
         if column == "type":
             values.append("select_one more_info")
         elif column == "label":
-            values.append("NO_LABEL")
+            values.append(strategy.get_empty_label())
         elif column == "name":
             values.append(get_export_name(node) + "_optin")
         elif column == "hint":

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/strategies/output/dhis2_form.py

@@ -25,6 +25,8 @@ from tricc_oo.models.tricc import (
     TriccNodeDisplayModel,
     TriccNodeCalculateBase,
     TriccNodeActivity,
+    TriccNodeSelect,
+    TriccNodeSelectYesNo,
 )
 from tricc_oo.models.calculate import TriccNodeDisplayCalculateBase
 from tricc_oo.models.ordered_set import OrderedSet
@@ -66,18 +68,22 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def get_export_name(self, r):
         if isinstance(r, TriccNodeSelectOption):
-            return self.get_option_value(r.name)
+            ret = self.get_option_value(r.name)
         elif isinstance(r, str):
-            return self.get_option_value(r)
+            ret = self.get_option_value(r)
         elif isinstance(r, TriccStatic):
             if isinstance(r.value, str):
-                return self.get_option_value(r.value)
+                ret = self.get_option_value(r.value)
             elif isinstance(r.value, bool):
-                return str(r.value).lower()
+                ret = str(r.value).lower()
             else:
-                return r.value
+                ret = r.value
+        else:
+            ret = get_export_name(r)
+        if isinstance(ret, str):
+            return ret[:50]
         else:
-            return get_export_name(r)
+            return ret
 
     def generate_id(self, name):
         """Generate DHIS2-compliant UID: 1 letter + 10 alphanumeric characters"""
@@ -139,7 +145,15 @@ class DHIS2Strategy(BaseOutPutStrategy):
             raise NotImplementedError(
                 f"This type of operation '{operation.operator}' is not supported in this strategy"
             )
-
+    def get_display(self, node):
+        if hasattr(node, 'label') and node.label:
+            ret =  node.label
+        elif hasattr(node, 'name') and node.name:
+            ret = node.name
+        else:
+            ret = str(node.id)
+        return  ret.replace('\u00a0', ' ').strip()
+    
     def execute(self):
         version = datetime.datetime.now().strftime("%Y%m%d%H%M")
         logger.info(f"build version: {version}")
@@ -223,11 +237,13 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     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(condition)
                     self.program_rules.append({
                         "id": rule_id,
-                        "name": f"Hide {node.get_name()} when condition met",
-                        "description": f"Hide {node.get_name()} based on relevance",
-                        "condition": f"!({relevance_str})",  # Negate for hide when true
+                        "name": f"Hide `{self.get_export_name(node)}` when condition met",
+                        "description": f"Hide `{self.get_display(node)}` based on relevance",
+                        "condition": condition,
                         "programRuleActions": [{"id": action_id}]
                     })
         return True
@@ -257,11 +273,15 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName": getattr(node, 'label', node.name).replace('\u00a0', ' ').strip(),
+                "displayFormName":self.get_display(node),
+                "formName": self.get_display(node),
                 "valueType": value_type,
                 "domainType": "TRACKER",
                 "aggregationType": "NONE"
             }
+            
+            if issubclass(node.__class__, TriccNodeSelect) and not isinstance(node, TriccNodeSelectYesNo):
+                data_element["optionSetValue"] = True
 
             # Only create optionSet for non-boolean select questions
             if node.tricc_type in ['select_one', 'select_multiple'] and not is_boolean_question:
@@ -273,7 +293,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     # Create the actual optionSet definition
                     option_set = {
                         "id": option_set_id,
-                        "name": f"{node.name} Options",
+                        "name": f"{self.get_export_name(node)} Options",
                         "shortName": f"{node.name}_opts"[:50],
                         "valueType": "TEXT",
                         "options": []
@@ -288,10 +308,10 @@ class DHIS2Strategy(BaseOutPutStrategy):
                                 option_name = option_name.replace('\u00a0', ' ').strip()
                             elif isinstance(option_name, TriccStatic):
                                 option_name = str(option_name.value)
-                            # Create separate option entity
+                            # Create separate option entityif
                             option_def = {
                                 "id": option_id,
-                                "name": option_name,
+                                "name": self.get_display(option),
                                 "shortName": option.name[:50],
                                 "code": str(self.get_export_name(option))
                             }
@@ -303,6 +323,20 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     self.option_sets[option_set_id] = option_set
 
             self.data_elements[node.name] = data_element
+
+            # Create program rule variable for this data element
+            var_id = self.generate_id(f"var_{node.name}")
+            var_name = self.get_export_name(node)
+            program_rule_variable = {
+                "id": var_id,
+                "name": var_name,
+                "programRuleVariableSourceType": "DATAELEMENT_CURRENT_EVENT",
+                "dataElement": {"id": de_id},
+                "program": {"id": self.program_metadata["id"]}
+            }
+            self.program_rule_variables.append(program_rule_variable)
+            self.concept_map[node.name] = var_name  # Store variable name for #{var_name} references
+
             return data_element
         return None
 
@@ -325,9 +359,10 @@ class DHIS2Strategy(BaseOutPutStrategy):
                         mock_node = MockNode(operation_datatype)
                         data_type = self.map_tricc_type_to_dhis2_value_type(mock_node)
 
+                var_name = self.get_export_name(node)
                 program_rule_variable = {
                     "id": var_id,
-                    "name": self.get_export_name(node.name)[:50],
+                    "name": var_name,
                     "programRuleVariableSourceType": "CALCULATED_VALUE",
                     "calculatedValueScript": expression_str,
                     "dataType": data_type,
@@ -336,7 +371,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 }
                 self.program_rule_variables.append(program_rule_variable)
                 # Add to concept map for potential referencing
-                self.concept_map[node.name] = var_id
+                self.concept_map[node.name] = var_name  # Store variable name
             return True
         return False
 
@@ -674,7 +709,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(r)
         elif isinstance(r, TriccReference):
-            # Use DHIS2 ID from concept_map instead of name
+            # Use variable name from concept_map
             node_id = self.concept_map.get(r.value.name, self.get_export_name(r.value))
             return f"#{{{node_id}}}"
         elif isinstance(r, TriccStatic):
@@ -696,25 +731,39 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 return option
             return f"'{option}'"
         elif issubclass(r.__class__, TriccNodeDisplayCalculateBase):
-            # Use DHIS2 ID from concept_map instead of name
-            node_id = self.concept_map.get(r.name, self.get_export_name(r))
-            return f"#{node_id}"
+            # Use variable name from concept_map
+            node_id = self.get_export_name(r)
+            return f"#{{{node_id}}}"
+        elif issubclass(r.__class__, TriccNodeCalculateBase):
+            # Use variable name from concept_map
+            node_id =  self.get_export_name(r)
+            return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeInputModel):
-            # Use DHIS2 ID from concept_map instead of name
-            node_id = self.concept_map.get(r.name, self.get_export_name(r))
+            # Use variable name from concept_map
+            node_id =  self.get_export_name(r)
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeBaseModel):
-            # Use DHIS2 ID from concept_map instead of name
-            node_id = self.concept_map.get(r.name, self.get_export_name(r))
+            # Use variable name from concept_map
+            node_id =  self.get_export_name(r)
             return f"#{{{node_id}}}"
         else:
             raise NotImplementedError(f"This type of node {r.__class__.__name__} is not supported within an operation")
 
+    def simplify_expression(self, expr):
+        while expr.startswith('!(!(') and expr.endswith('))'):
+            expr = expr[4:-2]
+        return expr
+
     def convert_expression_to_string(self, expression):
         if isinstance(expression, TriccOperation):
-            return self.get_tricc_operation_expression(expression)
+            expr = self.get_tricc_operation_expression(expression)
         else:
-            return self.get_tricc_operation_operand(expression)
+            expr = self.get_tricc_operation_operand(expression)
+
+        # Simplify double negations
+        expr = self.simplify_expression(expr)
+
+        return expr
 
     # Operation methods for DHIS2 expressions
     def tricc_operation_equal(self, ref_expressions):
@@ -765,7 +814,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def tricc_operation_selected(self, ref_expressions):
         # For DHIS2, check if value is selected in multi-select
-        return f"d2:hasValue({ref_expressions[0]}) && d2:contains({ref_expressions[0]}, {ref_expressions[1]})"
+        return f"d2:countIfValue({ref_expressions[0]}, {ref_expressions[1]})>0"
 
     def tricc_operation_count(self, ref_expressions):
         return f"d2:count({ref_expressions[0]})"

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/strategies/output/xls_form.py

@@ -495,7 +495,12 @@ class XLSFormStrategy(BaseOutPutStrategy):
         parts = []
         for s in ref_expressions[1:]:
             # for option with numeric value
-            cleaned_s = s if isinstance(s, str) else "'" + str(s) + "'"
+            if isinstance(s, str):
+                cleaned_s = s
+            elif isinstance(s, TriccNodeSelectOption):
+                cleaned_s = s.name
+            else:
+                cleaned_s = "'" + str(s) + "'"
             parts.append(f"selected({self.clean_coalesce(ref_expressions[0])}, {cleaned_s})")
         if len(parts) == 1:
             return parts[0]
@@ -589,11 +594,14 @@ class XLSFormStrategy(BaseOutPutStrategy):
             exp += ")"
         return exp
 
+    def get_empty_label(self):
+        return "."
+
     def tricc_operation_if(self, ref_expressions):
         return f"if({ref_expressions[0]},{ref_expressions[1]},{ref_expressions[2]})"
 
     def tricc_operation_contains(self, ref_expressions):
-        return f"contains('{self.clean_coalesce(ref_expressions[0])}', '{self.clean_coalesce(ref_expressions[1])}')"
+        return f"contains({self.clean_coalesce(ref_expressions[0])}, {self.clean_coalesce(ref_expressions[1])})"
 
     def tricc_operation_exists(self, ref_expressions):
         parts = []
@@ -721,11 +729,12 @@ class XLSFormStrategy(BaseOutPutStrategy):
         # @param r reference to be translated
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(r)
+        elif isinstance(r, (TriccStatic, str, int, float)):
+            return get_export_name(r)
         elif isinstance(r, TriccReference):
             logger.warning(f"reference `{r.value}` still used in a calculate")
             return f"${{{get_export_name(r.value)}}}"
-        elif isinstance(r, (TriccStatic, str, int, float)):
-            return get_export_name(r)
+
         elif isinstance(r, TriccNodeSelectOption):
             logger.debug(f"select option {r.get_name()} from {r.select.get_name()} was used as a reference")
             return get_export_name(r)

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/strategies/output/xlsform_cht.py

@@ -33,6 +33,9 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
 
         self.inject_version()
 
+    def get_empty_label(self):
+        return "NO_LABEL"
+
     def get_cht_input(self, start_pages, **kwargs):
         empty = langs.get_trads("", force_dict=True)
         df_input = pd.DataFrame(columns=SURVEY_MAP.keys())

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6}/tricc_oo/visitors/tricc.py

@@ -542,6 +542,32 @@ def generate_calculates(node, calculates, used_calculates, processed_nodes, proc
             for calc in list_calc:
                 node.activity.nodes[calc.id] = calc
                 add_calculate(calculates, calc)
+
+    # Add CONTAINS calculations for each option in select multiple (except opt_none)
+    if isinstance(node, TriccNodeSelectMultiple):
+        for option in node.options.values():
+            if not option.name.startswith("opt_"):
+                calc_id = generate_id(f"contains_{node.id}_{option.name}")
+                expression = TriccOperation(TriccOperator.CONTAINS, [node, TriccStatic(option.name)])
+                calc_node = TriccNodeCalculate(
+                    name=option.name,
+                    id=calc_id,
+                    group=node.group,
+                    activity=node.activity,
+                    label=f"contains: {node.get_name()} contains '{option.name}'",
+                    path_len=node.path_len + 1,
+                    last=True,
+                    expression=expression,
+                )
+                node.activity.calculates.append(calc_node)
+                last_version = set_last_version_false(calc_node, processed_nodes)
+                if last_version:
+                    calc_node.expression = merge_expression(calc_node.expression, last_version)
+                processed_nodes.add(calc_node)
+                list_calc.append(calc_node)
+                node.activity.nodes[calc_node.id] = calc_node
+                add_calculate(calculates, calc_node)
+
     return list_calc
 
 
@@ -1711,6 +1737,7 @@ 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
 
@@ -1737,6 +1764,9 @@ 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
@@ -1998,7 +2028,7 @@ def get_accept_diagnostic_node(code, display, severity, priority, activity):
     return node
 
 
-def get_diagnostic_node(code, display, severity, priority, activity):
+def get_diagnostic_node(code, display, severity, priority, activity, option):
     node = TriccNodeCalculate(
         id=generate_id("final." + code),
         name="final." + code,
@@ -2009,7 +2039,7 @@ def get_diagnostic_node(code, display, severity, priority, activity):
         expression_reference=or_join(
             [
                 TriccOperation(TriccOperator.ISTRUE, [TriccReference("pre_final." + code)]),
-                TriccOperation(TriccOperator.SELECTED, [TriccReference("tricc.manual.diag"), TriccStatic(code)]),
+                TriccOperation(TriccOperator.SELECTED, [TriccReference("tricc.manual.diag"), TriccStatic(option)]),
             ]
         ),
     )
@@ -2068,9 +2098,18 @@ def create_determine_diagnosis_activity(diags):
         group=activity,
         required=TriccStatic(False),
     )
+    options = []
     for proposed in diags:
+        option =  TriccNodeSelectOption(
+            id=generate_id(proposed.name),
+            name=proposed.name,
+            label=proposed.label,
+            list_name=f.list_name,
+            relevance=proposed.activity.applicability,
+            select=f,
+        )
         d = get_accept_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity)
-        c = get_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity)
+        c = get_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity, option)
         diags_conf.append(d)
         r = TriccNodeRhombus(
             path=start,
@@ -2095,17 +2134,7 @@ def create_determine_diagnosis_activity(diags):
         activity.nodes[wait2.id] = wait2
     # fallback
 
-    options = [
-        TriccNodeSelectOption(
-            id=generate_id(d.name),
-            name=d.name,
-            label=d.label,
-            list_name=f.list_name,
-            relevance=d.activity.applicability,
-            select=f,
-        )
-        for d in diags
-    ]
+    
     f.options = dict(zip(range(0, len(options)), options))
     activity.nodes[f.id] = f
     set_prev_next_node(f, end, edge_only=False)
@@ -2213,10 +2242,22 @@ def get_count_terms(node, processed_nodes, get_overall_exp, negate=False, proces
         return TriccOperation(TriccOperator.PLUS, [TriccOperation(TriccOperator.CAST_NUMBER, [term]) for term in terms])
 
 
+def get_none_option(node):
+    if hasattr(node, "options"):
+        for opt in node.options.values():
+            if opt.name == "opt_none":
+                return opt
+    return None
+
+
 def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=False, process=None):
-    operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic("opt_none")])
+    opt_none = get_none_option(prev_node)
+    if opt_none:
+        operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(opt_none)])
+    else:
+        operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic("opt_none")])
     if isinstance(prev_node, TriccNodeSelectYesNo):
-        return TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(prev_node.options[0].name)])
+        return TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(prev_node.options[0])])
     elif issubclass(prev_node.__class__, TriccNodeSelect):
         if negate:
             return
@@ -2528,7 +2569,7 @@ def get_selected_option_expression_single(option_node, negate):
 
 def get_selected_option_expression_multiple(option_node, negate):
 
-    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, option_node])
+    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, TriccStatic(option_node)])
 
     if negate:
         return TriccOperation(
@@ -2598,24 +2639,26 @@ def generate_base(node, processed_nodes, **kwargs):
             # we don't overright if define in the diagram
             if node.constraint is None:
                 if isinstance(node, TriccNodeSelectMultiple):
-                    node.constraint = or_join(
-                        [
-                            TriccOperation(
-                                TriccOperator.EQUAL,
-                                ["$this", TriccStatic("opt_none")],
-                            ),
-                            TriccOperation(
-                                TriccOperator.NOT,
-                                [
-                                    TriccOperation(
-                                        TriccOperator.SELECTED,
-                                        ["$this", TriccStatic("opt_none")],
-                                    )
-                                ],
-                            ),
-                        ]
-                    )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
-                    node.constraint_message = "**None** cannot be selected together with choice."
+                    none_opt = get_none_option(node)
+                    if none_opt:
+                        node.constraint = or_join(
+                            [
+                                TriccOperation(
+                                    TriccOperator.EQUAL,
+                                    ["$this", TriccStatic(none_opt)],
+                                ),
+                                TriccOperation(
+                                    TriccOperator.NOT,
+                                    [
+                                        TriccOperation(
+                                            TriccOperator.SELECTED,
+                                            ["$this", TriccStatic(none_opt)],
+                                        )
+                                    ],
+                                ),
+                            ]
+                        )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
+                        node.constraint_message = "**None** cannot be selected together with choice."
                 elif node.tricc_type in (
                     TriccNodeType.integer,
                     TriccNodeType.decimal,

{tricc_oo-1.6.5.dev1 → tricc_oo-1.6.6/tricc_oo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.5.dev1
+Version: 1.6.6
 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.5.dev1 → tricc_oo-1.6.6}/tricc_oo.egg-info/top_level.txt

@@ -2,7 +2,6 @@ build
 diagrams
 dist
 locales
-test_output
 tests
 tricc_oo
 uploads