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

tricc_oo/visitors/tricc.py

@@ -28,6 +28,7 @@ from tricc_oo.models.calculate import (
     TriccNodeActivityEnd,
     TriccNodeActivityStart,
     TriccNodeEnd,
+    TriccNodeDiagnosis,
     get_node_from_id,
 
 )
@@ -120,27 +121,16 @@ def get_last_version(name, processed_nodes, _list=None):
 # node is the node to calculate
 # processed_nodes are the list of processed nodes
 def get_node_expressions(node, processed_nodes, process=None):
-    get_overall_exp = issubclass(node.__class__, TriccNodeCalculateBase) and not issubclass(
-        node.__class__, (TriccNodeDisplayBridge, TriccNodeBridge)
-    )
+    get_overall_exp = issubclass(
+        node.__class__,
+        (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)
+    ) and not isinstance(node, (TriccNodeDisplayBridge))
     expression = None
     # in case of recursive call processed_nodes will be None
     if processed_nodes is None or is_ready_to_process(node, processed_nodes=processed_nodes):
         expression = get_node_expression(
             node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, process=process
         )
-
-    # if get_overall_exp:
-    #     if expression  and (not isinstance(expression, str) or expression != '')
-    #           and  expression is not TriccStatic(True) :
-    #         num_expression = TriccOperation(
-    #             TriccOperator.CAST_NUMBER,
-    #             [expression]
-    #         )
-    #     elif expression is TriccStatic(True)  or (not expression and get_overall_exp):
-    #         expression = TriccStatic(True)
-    #     else:
-    #         expression = None
     if (
         issubclass(node.__class__, TriccNodeCalculateBase)
         and not isinstance(expression, (TriccStatic, TriccReference, TriccOperation))
@@ -186,16 +176,22 @@ def get_version_inheritance(node, last_version, processed_nodes):
                     node.relevance = expression
     else:
         node.last = False
+
+        # Create a calculate node that coalesces the previous saved value with the current node value
+        calc_id = generate_id(f"save_{node.save}")
         calc = TriccNodeCalculate(
-            id=generate_id(f"save{node.id}"),
-            name=node.name,
+            id=calc_id,
+            name=node.save,
             path_len=node.path_len + 1,
-            # version=get_next_version(node.name, processed_nodes, node.version+2),
-            expression=merge_expression(node, last_version),
-            label=f"merge{node.id}",
-            last=True,
+            expression_reference=TriccOperation(
+                TriccOperator.COALESCE,
+                [TriccReference(node.save), last_version],
+            ),
+            reference=[TriccReference(node.name)],
             activity=node.activity,
             group=node.group,
+            label=f"Save calculation for {node.label}",
+            last=True,
         )
         node.activity.nodes[calc.id] = calc
         node.activity.calculates.append(calc)
@@ -549,6 +545,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
 
 
@@ -1564,7 +1586,12 @@ def set_prev_next_node(source_node, target_node, replaced_node=None, edge_only=F
         set_next_node(source_node, target_node, replaced_node, edge_only)
 
     if activity and not any([(e.source == source_id) and (e.target == target_id) for e in activity.edges]):
-        label = "continue" if issubclass(source_node.__class__, TriccNodeSelect) else None
+        if issubclass(source_node.__class__, TriccNodeSelect):
+            label = "continue"
+        elif isinstance(source_node, TriccNodeRhombus):
+            label = "yes"
+        else:
+            label = None
         activity.edges.append(TriccEdge(id=generate_id(), source=source_id, target=target_id, value=label))
 
 
@@ -1713,6 +1740,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
 
@@ -1739,6 +1767,12 @@ 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
@@ -1848,6 +1882,16 @@ def get_node_expression(in_node, processed_nodes, get_overall_exp=False, is_prev
             logger.critical(f"Rhombus without expression {node.get_name()}")
     elif is_prev and issubclass(node.__class__, TriccNodeDisplayCalculateBase):
         expression = TriccOperation(TriccOperator.ISTRUE, [node])
+        prev_exp_overall = get_node_expression(
+            node,
+            processed_nodes=processed_nodes,
+            get_overall_exp=False,
+            is_prev=False,
+            process=process,
+            negate=negate
+        )
+        if prev_exp_overall in [TriccStatic(True), TriccStatic(False)]:
+            expression = prev_exp_overall
     elif hasattr(node, "expression_reference") and isinstance(node.expression_reference, TriccOperation):
         # if issubclass(node.__class__, TriccNodeDisplayCalculateBase):
         #     expression = TriccOperation(
@@ -1925,7 +1969,6 @@ def get_prev_instance_skip_expression(node, processed_nodes, process, expression
                 ),
             )
         if expression and expression_inputs:
-            add_sub_expression(expression_inputs, expression)
             expression = nand_join(expression, or_join(expression_inputs))
         elif expression_inputs:
             expression = negate_term(or_join(expression_inputs))
@@ -1991,7 +2034,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,
@@ -2002,7 +2045,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)]),
             ]
         ),
     )
@@ -2061,9 +2104,19 @@ 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,
+        )
+        options.append(option)
         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,
@@ -2088,17 +2141,6 @@ 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)
@@ -2141,7 +2183,7 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
                     processed_nodes=processed_nodes,
                     get_overall_exp=get_overall_exp,
                     is_prev=True,
-                    process=process,
+                    process=get_overall_exp,
                 )
                 if isinstance(node, TriccNodeActivity) or get_overall_exp:
                     add_sub_expression(act_expression_inputs, sub)
@@ -2150,11 +2192,12 @@ def get_prev_node_expression(node, processed_nodes, get_overall_exp=False, exclu
 
         if act_expression_inputs:
             act_sub = or_join(act_expression_inputs)
+            # if there is condition fallback on the calling activity condition
             if act_sub == TriccStatic(True):
                 act_sub = get_node_expression(
                     prev_node.activity,
                     processed_nodes=processed_nodes,
-                    get_overall_exp=True,
+                    get_overall_exp=get_overall_exp,
                     is_prev=True,
                     negate=False,
                     process=process,
@@ -2205,10 +2248,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
@@ -2241,7 +2296,7 @@ def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=
                                     get_node_expression(
                                         prev_node,
                                         processed_nodes=processed_nodes,
-                                        get_overall_exp=True,
+                                        get_overall_exp=get_overall_exp,
                                         is_prev=True,
                                         process=process,
                                     )
@@ -2258,7 +2313,11 @@ def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=
                 TriccOperator.CAST_NUMBER,
                 [
                     get_node_expression(
-                        prev_node, processed_nodes=processed_nodes, get_overall_exp=True, is_prev=True, process=process
+                        prev_node,
+                        processed_nodes=processed_nodes,
+                        get_overall_exp=get_overall_exp,
+                        is_prev=True,
+                        process=process
                     )
                 ],
             )
@@ -2279,7 +2338,7 @@ def get_add_terms(node, processed_nodes, get_overall_exp=False, negate=False, pr
                         get_node_expression(
                             prev_node,
                             processed_nodes=processed_nodes,
-                            get_overall_exp=True,
+                            get_overall_exp=get_overall_exp,
                             is_prev=True,
                             process=process,
                         )
@@ -2352,7 +2411,11 @@ def get_rhombus_terms(node, processed_nodes, get_overall_exp=False, negate=False
                 TriccOperator.CAST_NUMBER,
                 [
                     get_node_expression(
-                        expression, processed_nodes=processed_nodes, get_overall_exp=True, is_prev=True, process=process
+                        expression,
+                        processed_nodes=processed_nodes,
+                        get_overall_exp=get_overall_exp,
+                        is_prev=True,
+                        process=process
                     )
                 ],
             )
@@ -2390,7 +2453,7 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
         return get_count_terms(node, False, negate, process=process)
     elif isinstance(node, TriccNodeRhombus):
         return get_rhombus_terms(
-            node, processed_nodes=processed_nodes, get_overall_exp=False, negate=negate, process=process
+            node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, negate=negate, process=process
         )
     elif isinstance(node, (TriccNodeWait)):
         # just use to force order of question
@@ -2407,7 +2470,6 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
         )
     elif isinstance(node, (TriccNodeActivityStart, TriccNodeActivityEnd)):
         # the group have the relevance for the activity, not needed to replicate it
-        # return get_prev_node_expression(node.activity, processed_nodes, get_overall_exp=False, excluded_name=None)
         expression = None
     elif isinstance(node, TriccNodeExclusive):
         if len(node.prev_nodes) == 1:
@@ -2420,7 +2482,7 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
                 return get_node_expression(
                     node_to_negate,
                     processed_nodes=processed_nodes,
-                    get_overall_exp=True,
+                    get_overall_exp=get_overall_exp,
                     is_prev=True,
                     negate=True,
                     process=process,
@@ -2429,7 +2491,7 @@ def get_calculation_terms(node, processed_nodes, get_overall_exp=False, negate=F
                 return get_node_expression(
                     node_to_negate,
                     processed_nodes=processed_nodes,
-                    get_overall_exp=True,
+                    get_overall_exp=get_overall_exp,
                     is_prev=True,
                     negate=True,
                     process=process,
@@ -2517,7 +2579,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(
@@ -2587,24 +2649,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,
@@ -2613,10 +2677,20 @@ def generate_base(node, processed_nodes, **kwargs):
                     constraints_min = ""
                     constraints_max = ""
                     if node.min is not None and node.min != "":
-                        constraints.append(TriccOperation(TriccOperator.MORE_OR_EQUAL, ["$this", node.min]))
-                        constraints_min = "The minimun value is {0}.".format(node.min)
+                        node.min = float(node.min)
+                        if int(node.min) == node.min:
+                            node.min = int(node.min)
+                        constraints.append(
+                            TriccOperation(TriccOperator.MORE_OR_EQUAL, ["$this", TriccStatic(node.min)])
+                        )
+                        constraints_min = "The minimum value is {0}.".format(node.min)
                     if node.max is not None and node.max != "":
-                        constraints.append(TriccOperation(TriccOperator.LESS_OR_EQUAL, ["$this", node.max]))
+                        node.max = float(node.max)
+                        if int(node.max) == node.max:
+                            node.max = int(node.max)
+                        constraints.append(
+                            TriccOperation(TriccOperator.LESS_OR_EQUAL, ["$this", TriccStatic(node.max)])
+                        )
                         constraints_max = "The maximum value is {0}.".format(node.max)
                     if len(constraints) > 1:
                         node.constraint = TriccOperation(TriccOperator.AND, constraints)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.5.26
+Version: 1.6.8
 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
@@ -24,6 +24,7 @@ Requires-Dist: antlr4-python3-runtime==4.13.2
 Requires-Dist: antlr4-tools==0.2.1
 Requires-Dist: beautifulsoup4
 Requires-Dist: ocldev
+Requires-Dist: pyxform
 Dynamic: license-file
 
 # TRICC-OO

{tricc_oo-1.5.26.dist-info → tricc_oo-1.6.8.dist-info}/RECORD

@@ -1,4 +1,5 @@
-tests/build.py,sha256=rAYR6cSsNtQLH5vvrh_FNSBwWh_AynF3jG28jC-tiGs,6670
+tests/build.py,sha256=Qbxvjkj_Wk2nQ-WjaMGiE1FIe3SRmJMRIgeoMoxqlfQ,6748
+tests/test_build.py,sha256=5t8iliPe_0XwoZjSGkHxUbZaNOWBfc6SpIQijh9DLUA,10037
 tests/test_cql.py,sha256=dAsLMqVaS6qxnq62fg5KqTFu6UG6pHO6Ab3NZ1c9T3Y,5248
 tests/to_ocl.py,sha256=4e-i65K3UM6wHgdVcrZcM9AyL1bahIsXJiZTXhhHgQk,2048
 tricc_oo/__init__.py,sha256=oWCE1ubmC_6iqaWOMgTei4eXVQgV202Ia-tXS1NnW_4,139
@@ -7,15 +8,15 @@ tricc_oo/converters/codesystem_to_ocl.py,sha256=Fh7Vk73OsxljZKu1k6H9uzYwz334tpQT
 tricc_oo/converters/cql_to_operation.py,sha256=PUyV_YpUY98Ox0H_F_CN3UUf_I-BhFZVOcWWKTtwecM,14492
 tricc_oo/converters/datadictionnary.py,sha256=T2HLCBo4Am1p0kFqSH1r0PqbD8AC2IGuWkbvMvSCru0,3658
 tricc_oo/converters/drawio_type_map.py,sha256=UCPiGs7Lw0bigKScmZUnmOhACBz-FiDq92jHkI7RTSQ,9113
-tricc_oo/converters/tricc_to_xls_form.py,sha256=Aor4Tfnz_Q-qUM9QVR2gzQln0zRoMfD1eHK7YkO-a9Y,3438
+tricc_oo/converters/tricc_to_xls_form.py,sha256=wsWv4aA0QssY7ry9R7KsuuMzVfovj9fwE3i9AtCum0c,3842
 tricc_oo/converters/utils.py,sha256=JZrtrvvOfXwdkw49pKauzinOcauWwsy-CVcw36TjyLo,1684
-tricc_oo/converters/xml_to_tricc.py,sha256=cDoLTwIMHIqyyNqZGwQte9YdX4y5j1Ac6r7M-zuKWZc,39403
+tricc_oo/converters/xml_to_tricc.py,sha256=PEBe8N-JIGJMVX2FO3UVxRcy5GrGsMvgcArEwUXmr6o,39572
 tricc_oo/converters/cql/cqlLexer.py,sha256=8HArbRphcrpnAG4uogJ2rHv4tc1WLzjN0B1uFeYILAc,49141
 tricc_oo/converters/cql/cqlListener.py,sha256=fA7-8DcS2Q69ckwjdg57-OfFHBxjTZFdoSKrtw7Hffc,57538
 tricc_oo/converters/cql/cqlParser.py,sha256=x3KdrwX9nwENSEJ5Ex7_l5NMnu3kWBO0uLdYu4moTq0,414745
 tricc_oo/converters/cql/cqlVisitor.py,sha256=iHuup2S7OGSVWLEcI4H3oecRqgXztC1sKnew_1P2iGY,33880
 tricc_oo/models/__init__.py,sha256=CgS52LLqdDIaXHvZy08hhu_VaYw80OEdfL_llM9ICBA,108
-tricc_oo/models/base.py,sha256=4mkAYAfvtdnTiLpUrttqQgIgfw1q_GkEgbVDKP8Txno,25849
+tricc_oo/models/base.py,sha256=saMpSiXnvQe_xkQ4PKJbNLqPkzZaiEGwb42HJ1CtwfM,25937
 tricc_oo/models/calculate.py,sha256=uNP0IDUqPQcJq9Co05H8eX5wbR_DikSxuOHxfVE5Dxg,8018
 tricc_oo/models/lang.py,sha256=ZMRwdoPWe01wEDhOM0uRk-6rt3BkoAAZM8mZ61--s3A,2265
 tricc_oo/models/ocl.py,sha256=MybSeB6fgCOUVJ4aektff0vrrTZsyfwZ2Gt_pPBu_FY,8728
@@ -25,26 +26,27 @@ tricc_oo/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 tricc_oo/parsers/xml.py,sha256=uzkb1y18MHfqVFmZqVh0sKT4cx6u0-NcAT_lV_gHBt8,4208
 tricc_oo/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/serializers/planuml.py,sha256=t57587-6L3aDncpHh58lS77Zft8yxDE9DPtXx2BeUSU,132
-tricc_oo/serializers/xls_form.py,sha256=9nUcdT2YVzJ2Hu7WLNmphxpXg3GU-yvY6j4ua3i_FCo,21636
+tricc_oo/serializers/xls_form.py,sha256=L0WF774zFt6PbdqncJGeyZzM9NiLq9NY5vO98yGTLhM,22133
 tricc_oo/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/base_input_strategy.py,sha256=BEODXS74na1QRRcJVQ4cxiD8F7uRqaLyhE3QzKpGVvk,3891
 tricc_oo/strategies/input/drawio.py,sha256=uXAUPhXOeg0Uk_BNqlCqFBW4cWNox4VfH559bj1fhC0,12767
-tricc_oo/strategies/output/base_output_strategy.py,sha256=M9UFR67-_CFoW681bPAeBS1OUGuFtmUbM_rltACI0hk,8798
+tricc_oo/strategies/output/base_output_strategy.py,sha256=i9L5CVUqkEAMNyBsdHJ4xA7Nptr3myHr_fHHveDX1cU,8928
+tricc_oo/strategies/output/dhis2_form.py,sha256=jW9NW72_61ch1bHm8ShIH4xsJH-HMlZGPTT5txJxMUk,38278
 tricc_oo/strategies/output/fhir_form.py,sha256=hbL921pe1Doun4IQrJuZ_Sq2fCh98G3grYie5olC4uc,15740
 tricc_oo/strategies/output/html_form.py,sha256=qSleEZOMV_-Z04y-i-ucyd5rgAYWAyjPwMrw0IHtCRM,8604
-tricc_oo/strategies/output/openmrs_form.py,sha256=aiHUi_lDm48yaKqZGWyFMVPIj6OhQGcAADFDoYJteW0,27175
+tricc_oo/strategies/output/openmrs_form.py,sha256=ne6TwAyhafR-WDs27QTKKFl85VD5sij_VEJtK6ZjOIE,28996
 tricc_oo/strategies/output/spice.py,sha256=QMeoismVC3PdbvwTK0PtUjWX9jl9780fbQIXn76fMXw,10761
-tricc_oo/strategies/output/xls_form.py,sha256=Qu6PSXHmtbCM8D0jB_hPZPW0Q5PUEMzsCvUcxzu7DuU,29711
+tricc_oo/strategies/output/xls_form.py,sha256=_pNTND7n-55EjRphJ1hSVtRYa-UkXlmwpam2OKQ8o_w,30860
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=X00Lt5MzV8TX14dR4dFI1MqllI5S1e13bKbeysWM9uA,17435
-tricc_oo/strategies/output/xlsform_cht.py,sha256=RY_mre9j6w2vVnRFSGn5R3CuTWFjIbQyl1uWwz9Ay5E,22965
+tricc_oo/strategies/output/xlsform_cht.py,sha256=eKAc6LLDnvdZ5m8a2Vk6eAhvPbUvOfykgYr0ou3an9k,27164
 tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=xm6SKirV3nMZvM2w54_zJcXAeAgAkq-EEqGEjnOWv6c,988
 tricc_oo/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tricc_oo/visitors/tricc.py,sha256=RtE1oY6pWBasOmx_njexBg4qlHwPZd08QR45St5fPW0,107095
+tricc_oo/visitors/tricc.py,sha256=8fULbAxKSeEtPyD5TYTaIG8-20Bjg2iZmzxcJM70n18,110295
 tricc_oo/visitors/utils.py,sha256=j83aAq5s5atXi3OC0jc_uJd54a8XrHHmizeeEbWZQJg,421
 tricc_oo/visitors/xform_pd.py,sha256=ryAnI3V9x3eTmJ2LNsUZfvl0_yfCqo6oBgeSu-WPqaE,9613
-tricc_oo-1.5.26.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-tricc_oo-1.5.26.dist-info/METADATA,sha256=6Mtk7f-ZpVaQdjAga1goridnvVfVg-qvorJ4PcjcqXg,8577
-tricc_oo-1.5.26.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tricc_oo-1.5.26.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.5.26.dist-info/RECORD,,
+tricc_oo-1.6.8.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+tricc_oo-1.6.8.dist-info/METADATA,sha256=g9u0_NdvNT8FFgNB3LQzsUADmGqL1PBB1DPdnCBKVuI,8599
+tricc_oo-1.6.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tricc_oo-1.6.8.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.6.8.dist-info/RECORD,,