tricc-oo 1.6.25__py3-none-any.whl → 1.7.0.dev1__py3-none-any.whl

tricc_oo/models/base.py

@@ -217,7 +217,6 @@ class TriccNodeBaseModel(TriccBaseModel):
     expression_inputs: List[Expression] = []
     activity: Optional[FwTriccNodeBaseModel] = None
     ref_def: Optional[Union[int, str]] = None  # for medal creator
-    is_sequence_defined: bool = False
 
     class Config:
         use_enum_values = True  # <--
@@ -275,7 +274,7 @@ class TriccNodeBaseModel(TriccBaseModel):
 
 
 class TriccStatic(BaseModel):
-    value: Union[str, float, int, bool, TriccNodeBaseModel]
+    value: Union[str, float, int, bool]
 
     def __init__(self, value):
         super().__init__(value=value)
@@ -378,7 +377,6 @@ class TriccOperator(StrEnum):
     PARENTHESIS = "parenthesis"
     CONCATENATE = "concatenate"
     DATETIME_TO_DECIMAL = "datetime_to_decimal"
-    DIAGNOSIS_LIST = "diagnosis_list"
 
 
 RETURNS_BOOLEAN = [
@@ -425,8 +423,6 @@ RETURNS_NUMBER = [
 
 RETURNS_DATE = [TriccOperator.CAST_DATE]
 
-RETURNS_STRING = [TriccOperator.DIAGNOSIS_LIST]
-
 OPERATION_LIST = {
     ">=": TriccOperator.MORE_OR_EQUAL,
     "<=": TriccOperator.LESS_OR_EQUAL,
@@ -484,8 +480,6 @@ class TriccOperation(BaseModel):
             return "number"
         elif self.operator in RETURNS_DATE:
             return "date"
-        elif self.operator in RETURNS_STRING:
-            return "string"
         elif self.operator == TriccOperator.CONCATENATE:
             return "string"
         elif self.operator == TriccOperator.PARENTHESIS:

tricc_oo/models/tricc.py

@@ -99,7 +99,6 @@ class TriccNodeActivity(TriccNodeBaseModel):
     # - case definition
     calculates: List[TriccNodeCalculateBase] = []
     applicability: Optional[Union[Expression, TriccOperation]] = None
-    is_sequence_defined: bool = False
 
     # redefine
     def make_instance(self, instance_nb=None, **kwargs):
@@ -295,15 +294,13 @@ class TriccNodeDisplayModel(TriccNodeBaseModel):
     default: Optional[Union[Expression, TriccOperation, TriccReference, TriccStatic]] = None
     trigger: Optional[Union[Expression, TriccOperation, TriccReference]] = None
     priority: Union[float, int, None] = None
-    concept_type: str = None
-    datatype: str = None
+
     # to use the enum value of the TriccNodeType
 
 
 class TriccNodeNote(TriccNodeDisplayModel):
     tricc_type: TriccNodeType = TriccNodeType.note
     datatype: str = "string"
-    is_sequence_defined: bool = True
 
 
 class TriccNodeInputModel(TriccNodeDisplayModel):
@@ -311,7 +308,6 @@ class TriccNodeInputModel(TriccNodeDisplayModel):
     constraint_message: Optional[Union[str, Dict[str, str]]] = None
     constraint: Optional[Expression] = None
     save: Optional[str] = None  # contribute to another calculate
-    is_sequence_defined: bool = True
 
 
 class TriccNodeDate(TriccNodeInputModel):

tricc_oo/serializers/xls_form.py

@@ -16,7 +16,7 @@ from tricc_oo.models.calculate import (
     TriccNodeCalculate
 )
 from tricc_oo.models.tricc import (
-    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
+    TriccNodeActivity, TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
     TriccNodeSelectOne,
     TriccNodeSelect,
     TriccNodeMoreInfo,
@@ -32,7 +32,6 @@ from tricc_oo.visitors.tricc import (
     get_applicability_expression,
     get_prev_instance_skip_expression,
     get_process_skip_expression,
-    process_operation_reference,
 )
 
 logger = logging.getLogger("default")
@@ -40,10 +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 get_export_group_required(in_node): return in_node.relevance  and in_node.relevance != TriccStatic(True)
+def get_export_group_name(in_node):return f"gcalc_{get_export_name(in_node)}"
 
 def start_group(
     strategy,
@@ -64,60 +60,40 @@ 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 != ""
     past_instances = len(getattr(cur_group.base_instance, "instances", []))
-    group_calc_required = get_export_group_required(cur_group)
+    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances>1)
     calc = None
-    if group_calc_required and len(df_calculate[df_calculate["name"] == get_export_group_name(cur_group)]) == 0:
-
+    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.group,
+            group=cur_group,
             activity=cur_group.activity,
             name=get_export_group_name(name),
             expression=cur_group.relevance
         )
-
-        if calc not in cur_group.activity.calculates:
-            process_reference(
-                calc,
-                processed_nodes,
-                calculates=kwargs.get('calculates', None),
-                used_calculates=kwargs.get('used_calculates', None),
-                replace_reference=True,
-                warn=False,
-                codesystems=kwargs.get('codesystems', None)
-            )
-            cur_group.activity.calculates.append(calc)
-            cur_group.activity.nodes[calc.id] = calc
+        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_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
-        relevance_expression = process_operation_reference(
-            relevance_expression,
-            cur_group,
-            processed_nodes=processed_nodes,
-            calculates=kwargs.get('calculates', None),
-            used_calculates=kwargs.get('used_calculates', None),
-            replace_reference=True,
-            warn=False,
-            codesystems=kwargs.get('codesystems', None),
-        ) or relevance_expression
-        if relevance_expression:
-            relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
-
+        relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
+    
     # group
     values = []
     for column in SURVEY_MAP:
@@ -138,7 +114,7 @@ def start_group(
     df_survey.loc[len(df_survey)] = values
 
     # calc
-    if calc and len(df_calculate[df_calculate["name"] == get_export_group_name(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":
@@ -147,7 +123,7 @@ def start_group(
                 value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(f"number({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:
@@ -357,7 +333,8 @@ def generate_choice_filter(strategy, node):
         choice_filter = TriccOperation(TriccOperator.OR, [basic])
         for k, op in relevances.items():
             choice_filter.append(
-                and_join(
+                TriccOperation(
+                    TriccOperator.AND,
                     [
                         TriccOperation(
                             TriccOperator.EQUAL,
@@ -367,7 +344,7 @@ def generate_choice_filter(strategy, node):
                             ],
                         ),
                         op,
-                    ]
+                    ],
                 )
             )
         return strategy.get_tricc_operation_expression(choice_filter)
@@ -432,7 +409,7 @@ def get_attr_if_exists(strategy, node, column, map_array):
         return ""
 
 
-def get_more_info_select(strategy, base_name, relevance):
+def get_more_info_select(strategy, node):
     values = []
     for column in SURVEY_MAP:
         if column == "type":
@@ -440,30 +417,28 @@ def get_more_info_select(strategy, base_name, relevance):
         elif column == "label":
             values.append(strategy.get_empty_label())
         elif column == "name":
-            values.append(base_name + "_optin")
+            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))
         elif column == "relevance":
-            values.append(relevance)
+            values.append(get_xfrom_trad(strategy, node.parent, column, SURVEY_MAP))
         else:
             values.append(get_xfrom_trad(strategy, None, column, SURVEY_MAP))
     return values
 
 
-def get_more_info_message(strategy, base_name, message):
+def get_more_info_message(strategy, node):
     values = []
     for column in SURVEY_MAP:
         if column == "type":
             values.append("note")
-        elif column == "name":
-            values.append(base_name)
         elif column == "relevance":
-            values.append(f"${{{base_name}_optin}} = 1")
-        elif column.startswith("label"):
-            arr = column.split("::")
-            column = arr[0]
-            trad = arr[1] if len(arr) == 2 else None
-            values.append(langs.get_trads(message, trad=trad))
+            values.append(f"${{{get_export_name(node)}_optin}} = 1")
+        elif column.startswith("hint"):
+            values.append(langs.get_trads("", trad=None))
         else:
-            values.append(get_xfrom_trad(strategy, None, column, SURVEY_MAP, clean_html=True))
+            values.append(get_xfrom_trad(strategy, node, column, SURVEY_MAP, clean_html=True))
     return values
 
 
@@ -484,13 +459,6 @@ def get_more_info_choice(strategy):
     return values
 
 
-def inject_more_info(strategy, base_name, relevance, message, df_survey, df_choice):
-    df_survey.loc[len(df_survey)] = get_more_info_select(strategy, base_name, relevance)
-    df_survey.loc[len(df_survey)] = get_more_info_message(strategy, base_name, message)
-    if len(df_choice[(df_choice["list_name"] == "more_info")]) == 0:
-        df_choice.loc[len(df_choice)] = get_more_info_choice(strategy)
-
-
 def generate_xls_form_export(
     strategy,
     node,
@@ -501,7 +469,6 @@ def generate_xls_form_export(
     df_calculate,
     cur_group,
     calculates,
-    help_before=False,
     **kwargs,
 ):
     # check that all prev nodes were processed
@@ -513,15 +480,6 @@ def generate_xls_form_export(
         codesystems=kwargs.get("codesystems", None),
     ):
         if node not in processed_nodes:
-            if help_before and getattr(node, 'help', None):
-                base_name=f"{get_export_name(node)}_more_info"
-                inject_more_info(
-                    strategy,
-                    base_name,
-                    get_xfrom_trad(strategy, node, "relevance", SURVEY_MAP),
-                    node.help,
-                    df_survey,
-                    df_choice)
             add_calculate(calculates, node)
             if node.group != cur_group and not isinstance(node, TriccNodeSelectOption):
                 return False
@@ -549,14 +507,10 @@ def generate_xls_form_export(
                     ):
                         df_choice.loc[len(df_choice)] = values
                 elif isinstance(node, TriccNodeMoreInfo):
-                    inject_more_info(
-                        strategy,
-                        get_export_name(node),
-                        get_xfrom_trad(strategy, node.parent, "relevance", SURVEY_MAP),
-                        node.label,
-                        df_survey,
-                        df_choice
-                    )
+                    df_survey.loc[len(df_survey)] = get_more_info_select(strategy, node)
+                    df_survey.loc[len(df_survey)] = get_more_info_message(strategy, node)
+                    if len(df_choice[(df_choice["list_name"] == "more_info")]) == 0:
+                        df_choice.loc[len(df_choice)] = get_more_info_choice(strategy)
                 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 = []
@@ -583,16 +537,6 @@ def generate_xls_form_export(
                         logger.warning("node {} have an unmapped type {}".format(node.get_name(), node.tricc_type))
                 else:
                     logger.warning("node {} have an unsupported type {}".format(node.get_name(), node.tricc_type))
-            if not help_before and getattr(node, 'help', None):
-                base_name=f"{get_export_name(node)}_more_info"
-                inject_more_info(
-                    strategy,
-                    base_name,
-                    get_xfrom_trad(strategy, node, "relevance", SURVEY_MAP),
-                    node.help,
-                    df_survey,
-                    df_choice
-                )
             # continue walk °
             return True
     return False

tricc_oo/strategies/output/base_output_strategy.py

@@ -43,9 +43,6 @@ class BaseOutPutStrategy:
 
         self.export(self.project.start_pages, version=version)
 
-        logger.info("validate the output")
-        self.validate()
-
     # walking function
     def process_base(self, start_pages, **kwargs):
         # for each node, check if condition is required issubclass(TriccNodeDisplayModel)
@@ -109,10 +106,6 @@ class BaseOutPutStrategy:
     def export(self, **kwargs):
         pass
 
-    @abc.abstractmethod
-    def validate(self):
-        pass
-
     def tricc_operation_equal(self, ref_expressions):
         # r[0] = r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")

tricc_oo/strategies/output/dhis2_form.py

@@ -145,16 +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
+            ret =  node.label
         elif hasattr(node, 'name') and node.name:
             ret = node.name
         else:
             ret = str(node.id)
-        return ret.replace('\u00a0', ' ').strip()
-
+        return  ret.replace('\u00a0', ' ').strip()
+    
     def execute(self):
         version = datetime.datetime.now().strftime("%Y%m%d%H%M")
         logger.info(f"build version: {version}")
@@ -274,12 +273,13 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName": self.get_display(node),
+                "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
 
@@ -736,15 +736,15 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeCalculateBase):
             # Use variable name from concept_map
-            node_id = self.get_export_name(r)
+            node_id =  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)
+            node_id =  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)
+            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")

tricc_oo/strategies/output/openmrs_form.py

@@ -410,7 +410,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         elif issubclass(r.__class__, TriccNodeInputModel):
             return self.get_export_name(r)
         elif issubclass(r.__class__, TriccNodeSelect):
-            return "(" + self.get_export_name(r) + " ?? [])"
+            return "(" + self.get_export_name(r) + " ?? [])"       
         elif issubclass(r.__class__, TriccNodeBaseModel):
             return self.get_export_name(r)
         else:
@@ -458,7 +458,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         return f"!({ref_expressions[0]})"
 
     def tricc_operation_plus(self, ref_expressions):
-        return "(" + " + ".join(ref_expressions) + ")"
+        return "(" + " + ".join(ref_expressions) +")" 
 
     def tricc_operation_minus(self, ref_expressions):
         if len(ref_expressions) > 1: