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

tricc_oo/serializers/xls_form.py

@@ -3,21 +3,32 @@ import hashlib
 
 # from bs4 import BeautifulSoup
 from tricc_oo.converters.tricc_to_xls_form import (
-    negate_term,
-    VERSION_SEPARATOR,
-    INSTANCE_SEPARATOR,
-    get_export_name,
+    get_export_name, BOOLEAN_MAP
 )
-from tricc_oo.converters.utils import clean_name, remove_html
 from tricc_oo.models.lang import SingletonLangClass
-from tricc_oo.models import *
-import re
+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 (
+    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
+    TriccNodeSelectOne,
+    TriccNodeSelect,
+    TriccNodeMoreInfo,
+    TriccNodeDisplayModel,
+    TriccNodeAcceptDiagnostic,
+    TriccNodeNote,
+)
+from typing import Dict
 from tricc_oo.visitors.tricc import (
     is_ready_to_process,
     process_reference,
     add_calculate,
-    TRICC_TRUE_VALUE,
-    TRICC_FALSE_VALUE,
     get_applicability_expression,
     get_prev_instance_skip_expression,
     get_process_skip_expression,
@@ -28,14 +39,20 @@ logger = logging.getLogger("default")
 langs = SingletonLangClass()
 TRICC_CALC_EXPRESSION = "${{{0}}}>0"
 
-BOOLEAN_MAP = {
-    str(TRICC_TRUE_VALUE): 1,
-    str(TRICC_FALSE_VALUE): 0,
-}
+
+def get_export_group_name(in_node): return f"gcalc_{get_export_name(in_node)}"
 
 
 def start_group(
-    strategy, cur_group, groups, df_survey, df_calculate, processed_nodes, process, relevance=False, **kwargs
+    strategy,
+    cur_group,
+    groups,
+    df_survey,
+    df_calculate,
+    processed_nodes,
+    process,
+    relevance=False,
+    **kwargs,
 ):
     name = get_export_name(cur_group)
 
@@ -45,35 +62,39 @@ def start_group(
 
     else:
         groups[name] = 0
-    is_activity = isinstance(cur_group, TriccNodeActivity)
-    relevance = (
-        relevance and cur_group.relevance is not None and cur_group.relevance != ""
-    )
-    
+    relevance = relevance and cur_group.relevance is not None and cur_group.relevance != ""
+    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)
 
-    group_calc_required = (
-        False and relevance and not is_activity and len(relevance) > 100
-    )
+        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
-        )
+        relevance_expression_str = 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)
-
-    ## group
+    # group
     values = []
     for column in SURVEY_MAP:
         if column == "type":
@@ -86,34 +107,27 @@ 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
-    ):
+    # calc
+    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(f"number({strategy.get_tricc_operation_expression(calc.expression)}")
             elif column == "relevance":
                 calc_values.append("")
             else:
-                calc_values.append(
-                    get_xfrom_trad(strategy, cur_group, column, SURVEY_MAP)
-                )
+                calc_values.append(get_xfrom_trad(strategy, cur_group, column, SURVEY_MAP))
 
         df_calculate.loc[len(df_calculate)] = calc_values
 
@@ -177,7 +191,8 @@ def end_group(strategy, cur_group, groups, df_survey, **kwargs):
     # if reference not in used_saves
     #   , then create calculate node reference_1 # and save is used_saves 'reference' : 1
     # else create calculate node reference_(used_saves['reference']+1) # and update used_saves['reference'] += 1
-    # once done, walkthrough again and remame  reference_(used_saves['reference']) to reference and create the other save
+    # once done, walkthrough again and remame
+    # reference_(used_saves['reference']) to reference and create the other save
 
 
 ODK_TRICC_TYPE_MAP = {
@@ -231,6 +246,7 @@ SURVEY_MAP = {
     **langs.get_trads_map("required_message"),
     "read only": "read only",
     "calculation": "expression",
+    "trigger": "trigger",
     "repeat_count": "repeat_count",
     "media::image": "image",
     "choice_filter": "",
@@ -257,13 +273,11 @@ def get_xfrom_trad(strategy, node, column, mapping, clean_html=False):
     new_column = arr[0] if arr[0] != "media" else "::".join(arr[0:2])
     trad = arr[-1] if new_column != column else None
     value = get_attr_if_exists(strategy, node, new_column, mapping)
-    # the pattern is to look for if that define a string if(test>0, 'strin')
-    pattern = r"concat\(|[^\}] *, *'[^']"
     if (
         issubclass(node.__class__, TriccNodeDisplayCalculateBase)
         and column == "calculation"
         and isinstance(value, str)
-        and not value.startswith("number")
+        and not (value.startswith("number") or value.startswith("round"))
         and getattr(node, "expression", None)
         and node.expression.get_datatype() in ("number", "boolean")
     ):
@@ -281,12 +295,7 @@ def get_xfrom_trad(strategy, node, column, mapping, clean_html=False):
             value = "autocomplete"
         elif isinstance(node, TriccNodeNote) and "countdown-timer" in node.name:
             value = "countdown-timer"
-    elif (
-        column == "appearance"
-        and isinstance(node, TriccNodeAcceptDiagnostic)
-        and node.severity
-        and not value
-    ):
+    elif column == "appearance" and isinstance(node, TriccNodeAcceptDiagnostic) and node.severity and not value:
         if node.severity == "severe":
             value = "severe"
         elif node.severity == "moderate":
@@ -310,7 +319,6 @@ def generate_choice_filter(strategy, node):
     if not isinstance(node, (TriccNodeSelectMultiple, TriccNodeSelectOne)):
         return
     relevances = {}
-    option_filter = {}
     for o in node.options.values():
         if o.relevance and o.relevance != TriccStatic(True):
             key = gen_operation_hash(o.relevance)
@@ -320,9 +328,7 @@ def generate_choice_filter(strategy, node):
         basic = "string-length(choice_filter)=0"
         # TODO remove when the bug regarding filter + image will be fixed
         if any(i.image is not None for i in node.options.values()):
-            basic = TriccOperation(
-                TriccOperator.AND, ["string-length(choice_filter)=0", node.relevance]
-            )
+            basic = TriccOperation(TriccOperator.AND, ["string-length(choice_filter)=0", node.relevance])
 
         choice_filter = TriccOperation(TriccOperator.OR, [basic])
         for k, op in relevances.items():
@@ -347,10 +353,7 @@ def generate_choice_filter(strategy, node):
 def get_attr_if_exists(strategy, node, column, map_array):
     if column in map_array:
         mapping = map_array[column]
-        if (
-            isinstance(mapping, Dict)
-            and getattr(node, "tricc_type", None) in map_array[column]
-        ):
+        if isinstance(mapping, Dict) and getattr(node, "tricc_type", None) in map_array[column]:
             tricc_type = map_array[column][node.tricc_type]
             if tricc_type[:6] == "select":
                 return tricc_type + " " + node.list_name
@@ -375,11 +378,7 @@ def get_attr_if_exists(strategy, node, column, map_array):
                         [
                             node.applicability,
                             value,
-                            (
-                                TriccStatic(False)
-                                if node.applicability.get_datatype() == "boolean"
-                                else TriccStatic("")
-                            ),
+                            (TriccStatic(False) if node.applicability.get_datatype() == "boolean" else TriccStatic("")),
                         ],
                     )
             if column == "name":
@@ -393,11 +392,7 @@ def get_attr_if_exists(strategy, node, column, map_array):
 
             elif isinstance(value, (TriccOperation, TriccStatic, TriccReference)):
                 expression = strategy.get_tricc_operation_expression(value)
-                return (
-                    expression.replace("$this", ".")
-                    if isinstance(expression, str)
-                    else expression
-                )
+                return expression
             elif value is not None:
                 return str(value) if not isinstance(value, dict) else value
             else:
@@ -420,14 +415,12 @@ 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":
             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(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
         elif column == "relevance":
             values.append(get_xfrom_trad(strategy, node.parent, column, SURVEY_MAP))
         else:
@@ -445,9 +438,7 @@ def get_more_info_message(strategy, node):
         elif column.startswith("hint"):
             values.append(langs.get_trads("", trad=None))
         else:
-            values.append(
-                get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True)
-            )
+            values.append(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
     return values
 
 
@@ -498,29 +489,18 @@ def generate_xls_form_export(
             if node in stashed_nodes:
                 stashed_nodes.remove(node)
                 if kwargs.get("warn", True):
-                    logger.debug(
-                        "generate_xls_form_export: unstashing processed node{} ".format(
-                            node.get_name()
-                        )
-                    )
-            if issubclass(
-                node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeDisplayModel)
-            ):
+                    logger.debug("generate_xls_form_export: unstashing processed node{} ".format(node.get_name()))
+            if issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeDisplayModel)):
                 if isinstance(node, TriccNodeSelectOption):
                     values = []
                     for column in CHOICE_MAP:
-                        values.append(
-                            get_xfrom_trad(strategy, node, column, CHOICE_MAP, True)
-                        )
+                        values.append(get_xfrom_trad(strategy, node, column, CHOICE_MAP, True))
                     # add only if not existing
                     if (
                         len(
                             df_choice[
                                 (df_choice["list_name"] == node.list_name)
-                                & (
-                                    df_choice["value"]
-                                    == BOOLEAN_MAP.get(str(node.name), node.name)
-                                )
+                                & (df_choice["value"] == BOOLEAN_MAP.get(str(node.name), node.name))
                             ]
                         )
                         == 0
@@ -528,34 +508,22 @@ 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
-                    )
+                    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)
-                elif (
-                    node.tricc_type in ODK_TRICC_TYPE_MAP
-                    and ODK_TRICC_TYPE_MAP[node.tricc_type] is not None
-                ):
+                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 = []
                         for column in SURVEY_MAP:
                             value = get_xfrom_trad(strategy, node, column, SURVEY_MAP)
                             if (
                                 column == "default"
-                                and issubclass(
-                                    node.__class__, TriccNodeDisplayCalculateBase
-                                )
+                                and issubclass(node.__class__, TriccNodeDisplayCalculateBase)
                                 and value == ""
                             ):
                                 value = 0
                             values.append(value)
-                        if (
-                            len(
-                                df_calculate[df_calculate.name == get_export_name(node)]
-                            )
-                            == 0
-                        ):
+                        if len(df_calculate[df_calculate.name == get_export_name(node)]) == 0:
                             df_calculate.loc[len(df_calculate)] = values
                         else:
                             df_calculate.loc[len(df_calculate)] = values
@@ -563,29 +531,19 @@ def generate_xls_form_export(
                     elif ODK_TRICC_TYPE_MAP[node.tricc_type] != "":
                         values = []
                         for column in SURVEY_MAP:
-                            values.append(
-                                get_xfrom_trad(strategy, node, column, SURVEY_MAP)
-                            )
+                            values.append(get_xfrom_trad(strategy, node, column, SURVEY_MAP))
                         df_survey.loc[len(df_survey)] = values
                     else:
-                        logger.warning(
-                            "node {} have an unmapped type {}".format(
-                                node.get_name(), node.tricc_type
-                            )
-                        )
+                        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
-                        )
-                    )
+                    logger.warning("node {} have an unsupported type {}".format(node.get_name(), node.tricc_type))
             # continue walk °
             return True
     return False
 
 
 def get_input_line(node, replace_dots=True):
-    label = langs.get_trads(node.label, force_dict=True)
+    # label = langs.get_trads(node.label, force_dict=True)
     empty = langs.get_trads("", force_dict=True)
     return [
         "hidden",
@@ -594,23 +552,24 @@ def get_input_line(node, replace_dots=True):
         *list(empty.values()),  # hint
         *list(empty.values()),  # help
         "",  # default
-        "hidden",  #'appearance', clean_name
-        "",  #'constraint',
-        *list(empty.values()),  #'constraint_message'
-        "",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(empty.values()),  #'required message'
-        "",  #'read only'
-        "",  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'
+        "hidden",  # 'appearance', clean_name
+        "",  # 'constraint',
+        *list(empty.values()),  # 'constraint_message'
+        "",  # 'relevance'
+        "",  # 'disabled'
+        "",  # 'required'
+        *list(empty.values()),  # 'required message'
+        "",  # 'read only'
+        "",
+        "",  # 'expression'
+        "",  # 'repeat_count'
+        "",  # 'image'
         "",
     ]
 
 
 def get_input_calc_line(node, replace_dots=True):
-    label = langs.get_trads(node.label, force_dict=True)
+    # label = langs.get_trads(node.label, force_dict=True)
     empty = langs.get_trads("", force_dict=True)
     return [
         "calculate",
@@ -619,19 +578,17 @@ def get_input_calc_line(node, replace_dots=True):
         *list(empty.values()),  # hint
         *list(empty.values()),  # help
         "",  # default
-        "",  #'appearance', clean_name
-        "",  #'constraint',
-        *list(empty.values()),  #'constraint_message'
-        "",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(empty.values()),  #'required message'
-        "",  #'read only'
-        "../inputs/contact/"
-        + clean_name(node.name, replace_dots=replace_dots),  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'
+        "",  # 'appearance', clean_name
+        "",  # 'constraint',
+        *list(empty.values()),  # 'constraint_message'
+        "",  # 'relevance'
+        "",  # 'disabled'
+        "",  # 'required'
+        *list(empty.values()),  # 'required message'
+        "",  # 'read only'
+        "../inputs/contact/" + clean_name(node.name, replace_dots=replace_dots),  # 'expression'
+        "",
+        "",  # 'repeat_count'
+        "",  # 'image'
         "",  # choice filter
     ]
-
-

tricc_oo/strategies/input/base_input_strategy.py

@@ -1,19 +1,16 @@
 import abc
 
-from tricc_oo.models import (
+from tricc_oo.models.tricc import (
     TriccNodeMainStart,
     TriccNodeActivity,
-    TriccEdge,
 )
 from tricc_oo.converters.utils import generate_id
 from tricc_oo.visitors.tricc import (
     get_activity_wait,
-    stashed_node_func,
     set_prev_next_node,
     export_proposed_diags,
-    create_determine_diagnosis_activity
+    create_determine_diagnosis_activity,
 )
-from itertools import chain
 import logging
 
 logger = logging.getLogger("default")
@@ -27,7 +24,14 @@ class BaseInputStrategy:
     def execute_linked_process(self, project):
         # create an overall activity only if not specified
         if "main" not in project.start_pages:
-            page_processes = [(p.root.process, p,) for p in list(project.pages.values()) if getattr(p.root, 'process', None)]
+            page_processes = [
+                (
+                    p.root.process,
+                    p,
+                )
+                for p in list(project.pages.values())
+                if getattr(p.root, "process", None)
+            ]
             sorted_pages = {}
             diags = []
             for a in project.pages.values():
@@ -38,34 +42,31 @@ class BaseInputStrategy:
                 if diag.name not in seen_diags:
                     unique_diags.append(diag)
                     seen_diags.add(diag.name)
-            severity_order = { "severe": 3, "moderate": 2, "mild":1, 'light': 0}
-            unique_diags = sorted(unique_diags, key=lambda x: (-getattr(severity_order, x.severity or 'light', 0), x.label))
+            severity_order = {"severe": 3, "moderate": 2, "mild": 1, "light": 0}
+            unique_diags = sorted(
+                unique_diags,
+                key=lambda x: (
+                    -getattr(severity_order, x.severity or "light", 0),
+                    x.label,
+                ),
+            )
             for process in self.processes:
                 if process in [p[0] for p in page_processes]:
-                    sorted_pages[process] = [
-                        p[1] for p in page_processes if p[0] == process
-                    ]                       
-                elif process == 'determine-diagnosis' and diags:
+                    sorted_pages[process] = [p[1] for p in page_processes if p[0] == process]
+                elif process == "determine-diagnosis" and diags:
                     diags_activity = create_determine_diagnosis_activity(unique_diags)
-                    sorted_pages[process] = [
-                        diags_activity
-                    ]
-                    project.start_pages['determine-diagnosis'] = diags_activity
+                    sorted_pages[process] = [diags_activity]
+                    project.start_pages["determine-diagnosis"] = diags_activity
             root_process = sorted_pages[list(sorted_pages.keys())[0]][0].root
             root = TriccNodeMainStart(
-                id=generate_id('s-main'),
+                id=generate_id("s-main"),
                 form_id=root_process.form_id,
                 label=root_process.label,
-                process='main'
+                process="main",
             )
             nodes = {}
             nodes[root.id] = root
-            app = TriccNodeActivity(
-                id=generate_id('a-main'),
-                name=root_process.name,
-                root=root,
-                nodes=nodes
-            )
+            app = TriccNodeActivity(id=generate_id("a-main"), name=root_process.name, root=root, nodes=nodes)
             root.activity = app
             # loop back to app to avoid None
             app.activity = app
@@ -85,20 +86,15 @@ class BaseInputStrategy:
                         )
                     else:
                         for a in nodes:
-                            set_prev_next_node(
-                                prev_bridge,
-                                a,
-                                edge_only=True
-                            )
+                            set_prev_next_node(prev_bridge, a, edge_only=True)
                     app.nodes[prev_bridge.id] = prev_bridge
-                    
+
                     for n in nodes.values():
                         n.activity = app
                         n.group = app
                         app.nodes[n.id] = n
                     prev_process = process
 
-
             return app
         else:
             return project.start_pages["main"]
@@ -106,7 +102,7 @@ class BaseInputStrategy:
     def __init__(self, input_path):
         self.input_path = input_path
 
-    ### walking function
+    # walking function
     @abc.abstractmethod
     def execute(in_filepath, media_path):
         pass