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

tests/build.py

@@ -6,6 +6,7 @@ from tricc_oo.strategies.output.xls_form import XLSFormStrategy  # noqa: F401
 from tricc_oo.strategies.output.openmrs_form import OpenMRSStrategy  # noqa: F401
 from tricc_oo.strategies.output.fhir_form import FHIRStrategy  # noqa: F401
 from tricc_oo.strategies.output.html_form import HTMLStrategy  # noqa: F401
+from tricc_oo.strategies.output.dhis2_form import DHIS2Strategy  # noqa: F401
 from tricc_oo.strategies.input.drawio import DrawioStrategy  # noqa: F401
 import getopt
 import logging

tricc_oo/converters/codesystem_to_ocl.py

@@ -31,16 +31,16 @@ def extract_properties_metadata(fhir_cs: CodeSystem) -> Dict[str, Dict]:
 
             property_types[prop.code] = {
                 "name": prop.code,
-                "datatype": ocl_type,
+                "dataType": ocl_type,
                 "description": prop.description if hasattr(prop, "description") else "",
             }
     return property_types
 
 
 def get_fhir_concept_datatype(concept):
-    datatype = extract_concept_properties(concept, ["datatype"])
+    datatype = extract_concept_properties(concept, ["dataType"])
     if datatype:
-        return datatype["datatype"]
+        return datatype["dataType"]
     else:
         return OclConstants.DATA_TYPE_NONE
 
@@ -84,7 +84,7 @@ def get_attributes_from_concept_properties(concept, property_types: Dict) -> Lis
                 "type": "Attribute",
                 "attribute_type": code,
                 "value": value,
-                "value_type": property_types[code]["datatype"],
+                "value_type": property_types[code]["dataType"],
             }
         )
     return attributes

tricc_oo/converters/datadictionnary.py

@@ -103,7 +103,7 @@ def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attr
                 # TODO support other type of Codesystem Concept Property Value
                 existing_attributes
                 if p.valueString != v:
-                    logger.warning(f"conflicting value for property {k}: {p.valueString} != {v}")
+                    logger.warning(f"conflicting value for concept `{concept.code}` property ` {k}`: {p.valueString} != {v}")
         if not existing_attributes:
             new_concept.property.append(CodeSystemConceptProperty(code=k, valueString=v))
 

tricc_oo/converters/drawio_type_map.py

@@ -47,7 +47,7 @@ TYPE_MAP = {
     },
     TriccNodeType.note: {
         "objects": ["UserObject", "object"],
-        "attributes": ["relevance", "priority", "context_type"],
+        "attributes": ["relevance", "priority", "concept_type"],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeNote,
     },
@@ -76,7 +76,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectOne,
@@ -94,7 +94,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectMultiple,
@@ -112,7 +112,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDecimal,
@@ -130,7 +130,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeInteger,
@@ -145,7 +145,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeText,
@@ -160,7 +160,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDate,
@@ -183,7 +183,7 @@ TYPE_MAP = {
             "save",
             "reference",
             "trigger",
-            "context_type",
+            "concept_type",
             "remote_reference",
         ],
         "mandatory_attributes": ["name", "label"],
@@ -217,7 +217,7 @@ TYPE_MAP = {
     },
     TriccNodeType.not_available: {
         "objects": ["UserObject", "object"],
-        "attributes": ["context_type"],
+        "attributes": ["concept_type"],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectNotAvailable,
     },
@@ -233,7 +233,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectYesNo,
@@ -295,7 +295,7 @@ TYPE_MAP = {
     },
     TriccNodeType.input: {
         "objects": ["UserObject", "object"],
-        "attributes": ["save", "reference", "datatype", "context_type"],
+        "attributes": ["save", "reference", "data_type", "concept_type"],
         "mandatory_attributes": ["name", "label"],
         "model": TriccNodeInput,
     },

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.converters.utils import clean_name
+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
 
@@ -36,13 +36,15 @@ def get_export_name(node, replace_dots=True):
     elif isinstance(node, bool):
         return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)] if node else BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
     elif isinstance(node, TriccReference):
-        logger.warning(f"Reference {node.value} use in export, bad serialiuation probable")
+        logger.warning(f"Reference {node.value} use in export, bad serialization probable")
         return str(node.value)
     elif isinstance(node, (str, TriccStatic, TriccNodeSelectOption)):
         if isinstance(node, TriccNodeSelectOption):
             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')
@@ -51,10 +53,12 @@ def get_export_name(node, replace_dots=True):
             export_name = BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]
         elif value == TRICC_FALSE_VALUE:
             export_name = BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
-        elif isinstance(value, str):
-            export_name = f"'{clean_str(value, replace_dots=replace_dots)}'"
+        elif value == '$this':
+            export_name = '.'
+        elif isinstance(value, str) and not isinstance(node, str):
+            export_name = f"'{value}'"
         else:
-            export_name = str(value)
+            export_name = value
         if hasattr(node, 'export_name'):
             node.export_name = export_name
         return export_name
@@ -62,7 +66,12 @@ 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(

tricc_oo/converters/xml_to_tricc.py

@@ -7,7 +7,7 @@ import re
 
 from tricc_oo.converters.utils import remove_html, clean_str
 from tricc_oo.converters.cql_to_operation import transform_cql_to_operation
-from tricc_oo.converters.utils import generate_id, get_rand_name
+from tricc_oo.converters.utils import generate_id
 from tricc_oo.models.base import (
     TriccOperator, TriccOperation,
     TriccStatic, TriccReference, TriccNodeType, TriccEdge, OPERATION_LIST
@@ -101,16 +101,16 @@ def create_activity(diagram, media_path, project):
 
     external_id = diagram.attrib.get("id")
     id = get_id(external_id, diagram.attrib.get("id"))
-    root = create_root_node(diagram)
-    name = diagram.attrib.get("name")
+    root, name = create_root_node(diagram)
+    label = diagram.attrib.get("name")
     form_id = diagram.attrib.get("name", None)
     if root is not None:
         activity = TriccNodeActivity(
             root=root,
-            name=get_rand_name(f"a{id}"),
+            name=name,  # start node 'name' is saved in label
             id=id,
             external_id=external_id,
-            label=name,
+            label=label,
             form_id=form_id,
         )
         if root.relevance is not None:
@@ -128,9 +128,9 @@ def create_activity(diagram, media_path, project):
         for n in nodes.values():
 
             if (
-                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase))
+                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeInput))
                 and not isinstance(n, (TriccRhombusMixIn, TriccNodeRhombus, TriccNodeDisplayBridge))
-                and not n.name.startswith("label_")
+                and not n.name.startswith("label_")  # FIXME
             ):
                 system = n.name.split(".")[0] if "." in n.name else "tricc"
                 if isinstance(n, TriccNodeSelectOption) and isinstance(n.select, TriccNodeSelectNotAvailable):
@@ -139,7 +139,7 @@ def create_activity(diagram, media_path, project):
                         system,
                         n.select.name,
                         n.label,
-                        {"datatype": "Boolean", "contextType": get_context_type(n)},
+                        {"dataType": "Boolean", "conceptType": get_concept_type(n)},
                     )
                 elif not isinstance(n, TriccNodeSelectNotAvailable):
                     add_concept(
@@ -148,8 +148,20 @@ def create_activity(diagram, media_path, project):
                         n.name,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
+                        },
+                    )
+                elif not issubclass(n.__class__, TriccNodeCalculate):
+                    system = n.name.split(".")[0] if "." in n.name else "calculate"
+                    add_concept(
+                        project.code_systems,
+                        system,
+                        n.name,
+                        n.label,
+                        {
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
                 if getattr(n, "save", None):
@@ -160,8 +172,8 @@ def create_activity(diagram, media_path, project):
                         n.save,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
 
@@ -175,7 +187,7 @@ def create_activity(diagram, media_path, project):
         # link back the activity
         activity.root.activity = activity
         manage_dangling_calculate(activity)
-
+        # assign the process
         if activity is not None:
             if activity.root is not None:
                 project.pages[activity.id] = activity
@@ -197,6 +209,7 @@ def create_activity(diagram, media_path, project):
                         )
         if images:
             project.images += images
+        # Assign parent to NotAvailable
         for node in list(
             filter(
                 lambda p_node: isinstance(p_node, TriccNodeSelectNotAvailable),
@@ -444,17 +457,18 @@ def create_root_node(diagram):
         if elm is not None:
             external_id = elm.attrib.get("id")
             id = get_id(external_id, diagram.attrib.get("id"))
+            name = generate_id("start"+external_id)
             node = TriccNodeActivityStart(
                 id=id,
                 external_id=external_id,
                 # parent=elm.attrib.get("parent"),
-                name="ma" + id,
+                name=name,
                 label=diagram.attrib.get("name"),
                 relevance=elm.attrib.get("relevance"),
                 instance=int(elm.attrib.get("instance") if elm.attrib.get("instance") is not None else 1),
             )
     load_expressions(node)
-    return node
+    return node, _get_name(elm.attrib.get("name", "act_"), external_id, diagram.attrib.get("id")) if node else None
 
 
 # converter XML item to object
@@ -476,10 +490,10 @@ def set_additional_attributes(attribute_names, elm, node):
             setattr(node, attributename, attribute)
 
 
-def get_context_type(node):
-    context_type = getattr(node, "context_type", None)
-    if context_type:
-        return context_type
+def get_concept_type(node):
+    concept_type = getattr(node, "concept_type", None)
+    if concept_type:
+        return concept_type
     if isinstance(node, TriccNodeSelectMultiple):
         return "Question"
     elif isinstance(node, TriccNodeSelectOption):
@@ -534,7 +548,7 @@ def get_select_options(diagram, select_node, nodes):
             activity=select_node.activity,
             group=select_node.group,
         )
-        set_additional_attributes(["save", "relevance", "context_type"], elm, option)
+        set_additional_attributes(["save", "relevance", "concept_type"], elm, option)
         load_expressions(option)
         options[i] = option
         nodes[id] = option
@@ -624,6 +638,8 @@ def enrich_node(diagram, media_path, edge, node, activity, help_before=False):
                     name=f"{node.name}.more_info",
                     label=message,
                     parent=node,
+                    group=node.group,
+                    activity=node.activity,
                     required=None,
                 )
                 # node.help = message
@@ -799,9 +815,11 @@ def set_mandatory_attribute(elm, mandatory_attributes, diagram=None):
             id = elm.attrib.get("id")
             attribute_value = _get_name(name, id, diagram_id)
         elif attributes == "list_name":
-            name = elm.attrib.get("name")
-            id = elm.attrib.get("id")
-            attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
+            attribute_value = elm.attrib.get("list_name", None)
+            if not attribute_value:
+                name = elm.attrib.get("name")
+                id = elm.attrib.get("id")
+                attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
         else:
             attribute_value = elm.attrib.get(attributes)
         if attribute_value is None:

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)
@@ -494,6 +494,8 @@ class TriccOperation(BaseModel):
                 return "mixed"
             else:
                 return rtype.pop()
+        else:
+            return self.get_reference_datatype(self.reference)
 
     def get_reference_datatype(self, references):
         rtype = set()

tricc_oo/serializers/xls_form.py

@@ -6,16 +6,17 @@ 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,
+    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
     TriccNodeSelectOne,
     TriccNodeSelect,
     TriccNodeMoreInfo,
@@ -31,6 +32,7 @@ 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")
@@ -39,6 +41,9 @@ 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,
     cur_group,
@@ -58,10 +63,38 @@ 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 = 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.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
+            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)
@@ -69,14 +102,20 @@ def start_group(
     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 = 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)
 
     # group
     values = []
@@ -91,23 +130,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(f"number({strategy.get_tricc_operation_expression(calc.expression)})")
             elif column == "relevance":
                 calc_values.append("")
             else:
@@ -376,7 +415,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:
@@ -399,7 +438,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/strategies/output/base_output_strategy.py

@@ -43,6 +43,9 @@ 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)
@@ -106,6 +109,10 @@ 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")