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

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

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

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

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

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

{tricc_oo-1.6.5 → tricc_oo-1.6.5.dev1}/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"^[^\\/\: ]+$")]
 

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

@@ -6,13 +6,14 @@ from tricc_oo.converters.tricc_to_xls_form import (
     get_export_name, BOOLEAN_MAP
 )
 from tricc_oo.models.lang import SingletonLangClass
-from tricc_oo.converters.utils import clean_name, remove_html
+from tricc_oo.converters.utils import clean_name, remove_html, generate_id
 from tricc_oo.models.base import (
     TriccOperator,
     TriccOperation, TriccStatic, TriccReference, and_join, TriccNodeType
 )
 from tricc_oo.models.calculate import (
     TriccNodeDisplayCalculateBase,
+    TriccNodeCalculate
 )
 from tricc_oo.models.tricc import (
     TriccNodeActivity, TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
@@ -38,6 +39,7 @@ logger = logging.getLogger("default")
 langs = SingletonLangClass()
 TRICC_CALC_EXPRESSION = "${{{0}}}>0"
 
+def get_export_group_name(in_node):return f"gcalc_{get_export_name(in_node)}"
 
 def start_group(
     strategy,
@@ -60,24 +62,38 @@ def start_group(
         groups[name] = 0
     is_activity = isinstance(cur_group, TriccNodeActivity)
     relevance = relevance and cur_group.relevance is not None and cur_group.relevance != ""
-
-    group_calc_required = False and relevance and not is_activity and len(relevance) > 100
-
+    past_instances = len(getattr(cur_group.base_instance, "instances", []))
+    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances>1)
+    calc = None
+    if group_calc_required and getattr(cur_group.relevance, 'operator', None) != TriccOperator.ISTRUE:
+        
+        calc = TriccNodeCalculate(
+            id=generate_id(get_export_group_name(name)),
+            group=cur_group,
+            activity=cur_group.activity,
+            name=get_export_group_name(name),
+            expression=cur_group.relevance
+        )
+        if calc not in cur_group.calculates:
+            cur_group.calculates.append(calc)
+            processed_nodes.add(calc)
+            
+        cur_group.relevance = TriccOperation(
+                TriccOperator.ISTRUE,
+                [calc]
+            )
+    
     relevance_expression = cur_group.relevance
     relevance_expression = get_applicability_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_prev_instance_skip_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_process_skip_expression(cur_group, processed_nodes, process, relevance_expression)
 
+
     if not relevance:
-        relevance_expression = ""
+        relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
-        relevance_expression = strategy.get_tricc_operation_expression(relevance_expression)
-
-    # elif is_activity:
-    #    relevance_expression = TRICC_CALC_EXPRESSION.format(get_export_name(cur_group.root))
-    elif group_calc_required:
-        relevance_expression = TRICC_CALC_EXPRESSION.format("gcalc_" + name)
-
+        relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
+    
     # group
     values = []
     for column in SURVEY_MAP:
@@ -91,23 +107,23 @@ def start_group(
             if relevance_expression is True:
                 values.append("")
             else:
-                values.append(relevance_expression)
+                values.append(relevance_expression_str)
 
         else:
             values.append(get_xfrom_trad(strategy, cur_group, column, SURVEY_MAP))
     df_survey.loc[len(df_survey)] = values
 
     # calc
-    if group_calc_required and len(df_calculate[df_calculate["name"] == "gcalc_" + name]) == 0:
+    if calc and len(df_calculate[df_calculate["name"] ==  get_export_group_name(name)]) == 0:
         calc_values = []
         for column in SURVEY_MAP:
             if column == "type":
                 calc_values.append("calculate")
             elif column == "name":
-                value = "gcalc_" + name
+                value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(get_attr_if_exists(strategy, cur_group, "relevance", SURVEY_MAP))
+                calc_values.append(strategy.get_tricc_operation_expression(calc.expression))
             elif column == "relevance":
                 calc_values.append("")
             else:
@@ -399,7 +415,7 @@ def get_more_info_select(strategy, node):
         if column == "type":
             values.append("select_one more_info")
         elif column == "label":
-            values.append(strategy.get_empty_label())
+            values.append("NO_LABEL")
         elif column == "name":
             values.append(get_export_name(node) + "_optin")
         elif column == "hint":

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

@@ -25,8 +25,6 @@ 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
@@ -68,22 +66,18 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def get_export_name(self, r):
         if isinstance(r, TriccNodeSelectOption):
-            ret = self.get_option_value(r.name)
+            return self.get_option_value(r.name)
         elif isinstance(r, str):
-            ret = self.get_option_value(r)
+            return self.get_option_value(r)
         elif isinstance(r, TriccStatic):
             if isinstance(r.value, str):
-                ret = self.get_option_value(r.value)
+                return self.get_option_value(r.value)
             elif isinstance(r.value, bool):
-                ret = str(r.value).lower()
+                return str(r.value).lower()
             else:
-                ret = r.value
-        else:
-            ret = get_export_name(r)
-        if isinstance(ret, str):
-            return ret[:50]
+                return r.value
         else:
-            return ret
+            return get_export_name(r)
 
     def generate_id(self, name):
         """Generate DHIS2-compliant UID: 1 letter + 10 alphanumeric characters"""
@@ -145,15 +139,7 @@ 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}")
@@ -237,13 +223,11 @@ 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 `{self.get_export_name(node)}` when condition met",
-                        "description": f"Hide `{self.get_display(node)}` based on relevance",
-                        "condition": condition,
+                        "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
                         "programRuleActions": [{"id": action_id}]
                     })
         return True
@@ -273,15 +257,11 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName":self.get_display(node),
-                "formName": self.get_display(node),
+                "displayFormName": getattr(node, 'label', node.name).replace('\u00a0', ' ').strip(),
                 "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:
@@ -293,7 +273,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
                     # Create the actual optionSet definition
                     option_set = {
                         "id": option_set_id,
-                        "name": f"{self.get_export_name(node)} Options",
+                        "name": f"{node.name} Options",
                         "shortName": f"{node.name}_opts"[:50],
                         "valueType": "TEXT",
                         "options": []
@@ -308,10 +288,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 entityif
+                            # Create separate option entity
                             option_def = {
                                 "id": option_id,
-                                "name": self.get_display(option),
+                                "name": option_name,
                                 "shortName": option.name[:50],
                                 "code": str(self.get_export_name(option))
                             }
@@ -323,20 +303,6 @@ 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
 
@@ -359,10 +325,9 @@ 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": var_name,
+                    "name": self.get_export_name(node.name)[:50],
                     "programRuleVariableSourceType": "CALCULATED_VALUE",
                     "calculatedValueScript": expression_str,
                     "dataType": data_type,
@@ -371,7 +336,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_name  # Store variable name
+                self.concept_map[node.name] = var_id
             return True
         return False
 
@@ -709,7 +674,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(r)
         elif isinstance(r, TriccReference):
-            # Use variable name from concept_map
+            # Use DHIS2 ID from concept_map instead of name
             node_id = self.concept_map.get(r.value.name, self.get_export_name(r.value))
             return f"#{{{node_id}}}"
         elif isinstance(r, TriccStatic):
@@ -731,39 +696,25 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 return option
             return f"'{option}'"
         elif issubclass(r.__class__, TriccNodeDisplayCalculateBase):
-            # 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}}}"
+            # 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}"
         elif issubclass(r.__class__, TriccNodeInputModel):
-            # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            # 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}}}"
         elif issubclass(r.__class__, TriccNodeBaseModel):
-            # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            # 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}}}"
         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):
-            expr = self.get_tricc_operation_expression(expression)
+            return self.get_tricc_operation_expression(expression)
         else:
-            expr = self.get_tricc_operation_operand(expression)
-
-        # Simplify double negations
-        expr = self.simplify_expression(expr)
-
-        return expr
+            return self.get_tricc_operation_operand(expression)
 
     # Operation methods for DHIS2 expressions
     def tricc_operation_equal(self, ref_expressions):
@@ -814,7 +765,7 @@ class DHIS2Strategy(BaseOutPutStrategy):
 
     def tricc_operation_selected(self, ref_expressions):
         # For DHIS2, check if value is selected in multi-select
-        return f"d2:countIfValue({ref_expressions[0]}, {ref_expressions[1]})>0"
+        return f"d2:hasValue({ref_expressions[0]}) && d2:contains({ref_expressions[0]}, {ref_expressions[1]})"
 
     def tricc_operation_count(self, ref_expressions):
         return f"d2:count({ref_expressions[0]})"

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

@@ -589,14 +589,11 @@ 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 = []

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

@@ -33,9 +33,6 @@ 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 → tricc_oo-1.6.5.dev1/tricc_oo.egg-info}/PKG-INFO

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

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