tricc-oo 1.4.16__py3-none-any.whl → 1.4.22__py3-none-any.whl

tests/build.py

@@ -145,7 +145,7 @@ if __name__ == "__main__":
     if in_filepath is None:
         print_help()
         sys.exit(2)
-    in_filepath_list = in_filepath.split(',')
+    
     if not download_dir:
         download_dir = out_path
     debug_path = os.fspath(out_path + "/debug.log")
@@ -165,6 +165,7 @@ if __name__ == "__main__":
         setup_logger("default", debug_file_path, logging.INFO)
     file_content = []
     files = []
+    in_filepath_list = in_filepath.split(',')
     for in_filepath in in_filepath_list:
         pre, ext = os.path.splitext(in_filepath)
 

tricc_oo/converters/cql_to_operation.py

@@ -33,6 +33,7 @@ FUNCTION_MAP = {
 class cqlToXlsFormVisitor(cqlVisitor):
     def __init__(self):
         self.xlsform_rows = []
+        self.errors= []
         
     def resolve_scv(self, arg):
         
@@ -42,9 +43,15 @@ class cqlToXlsFormVisitor(cqlVisitor):
         # if no code or not found return None
         if arg.startswith('"') and arg.endswith('"'):
             return TriccReference(arg[1:-1])
-        else:
+        elif arg.lower() in ['true', 'false']:
+            return TriccStatic(arg.lower() == 'true')
+        elif arg != 'runner':
+            self.errors.append(f"'{arg}' will be poccessed as reference ")
             return TriccReference(arg)
         
+        else:
+            return 'runner'
+        
     def translate(self, arg, type=ANY):
         return self.resolve_scv(arg) or str(arg)
     
@@ -150,6 +157,13 @@ class cqlToXlsFormVisitor(cqlVisitor):
         function_name = ctx.getChild(2).getText()
         return not_clean(self._get_membership_expression(ctx, function_name))
     
+    def visitInvocationExpressionTerm(self, ctx):
+        result = super().visitInvocationExpressionTerm(ctx)
+        if isinstance(result, list) and all(isinstance(x, TriccStatic) for x in result):
+            value = '.'.join([x.value for x in result])
+            logger.warning(f"guessed reference for '{value}'")
+            return TriccReference(value)
+        return result
 
     def visitBetweenExpression(self, ctx):
         ref = self.visit(ctx.expression(0))
@@ -361,13 +375,13 @@ class CQLErrorListener(ErrorListener):
         self.errors.append(error)
 
 def transform_cql_to_operation(cql_input, context=None):
-    cql_input = f"""
+    lib_input = f"""
     library runner
     
     define "calc":
         {cql_input.replace('−', '-')}
     """
-    input_stream = InputStream(chr(10).join(cql_input.split('\n')))
+    input_stream = InputStream(chr(10).join(lib_input.split('\n')))
     lexer = cqlLexer(input_stream)
     stream = CommonTokenStream(lexer)
     parser = cqlParser(stream)
@@ -383,12 +397,18 @@ def transform_cql_to_operation(cql_input, context=None):
     # Check for errors
     if error_listener.errors:
         for error in error_listener.errors:
-            print(f"CQL Grammar Error: {error}")
+            print(f"CQL Grammar Error: {error} \n in:\n {cql_input}")
         return None  # Or handle errors as appropriate for your use case
 
     # If no errors, proceed with visitor
     visitor = cqlToXlsFormVisitor()
+    
     visitor.visit(tree)
+    if visitor.errors:
+        logger.warning(f"while visiting cql: \n{cql_input}")
+        for e in visitor.errors:
+            logger.warning(e)
+        
     return visitor.xlsform_rows[0]['calculation']
 
 def transform_cql_lib_to_operations(cql_input):

tricc_oo/converters/datadictionnary.py

@@ -16,6 +16,10 @@ logger = logging.getLogger("default")
 
 
 def lookup_codesystems_code(codesystems, ref):
+    if ref.startswith('final.'):
+        concept = lookup_codesystems_code(codesystems, ref[6:])
+        if concept:
+            return concept
     for code_system in codesystems.values():
         for concept in code_system.concept or []:
             if concept.code == ref:

tricc_oo/converters/drawio_type_map.py

@@ -94,13 +94,13 @@ TYPE_MAP = {
 
     TriccNodeType.text: {
         "objects": ["UserObject", "object"],
-        "attributes": ["relevance"],
+        "attributes": ["save", "relevance"],
         "mandatory_attributes": ["label", 'name'],
         "model": TriccNodeText
     },
     TriccNodeType.date: {
         "objects": ["UserObject", "object"],
-        "attributes": ["relevance"],
+        "attributes": ["save", "relevance"],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDate
     },

tricc_oo/converters/tricc_to_xls_form.py

@@ -35,12 +35,12 @@ def get_export_name(node, replace_dots=True):
         node.gen_name()
         if isinstance(node, TriccNodeSelectOption):
                 node.export_name = node.name
-        elif isinstance(node,  TriccNodeActivityStart):
-            node.export_name =  clean_name(node.name +  INSTANCE_SEPARATOR + str(node.instance), replace_dots=replace_dots)
-        elif isinstance(node, TriccNodeInput):
-            node.export_name = clean_name('load.' +node.name, replace_dots=replace_dots)
         elif node.last == False:
             node.export_name = clean_name(node.name + VERSION_SEPARATOR + str(node.version), replace_dots=replace_dots)
+        elif node.activity.instance>1:
+            node.export_name =  clean_name(node.name +  INSTANCE_SEPARATOR + str(node.activity.instance), replace_dots=replace_dots)
+        elif isinstance(node, TriccNodeInput):
+            node.export_name = clean_name('load.' +node.name, replace_dots=replace_dots)
         else:
             node.export_name = clean_name(node.name, replace_dots=replace_dots)
             

tricc_oo/converters/xml_to_tricc.py

@@ -35,6 +35,7 @@ DISPLAY_ATTRIBUTES = [
     'help'
 ]
 logger = logging.getLogger("default")
+import html2text
 
 
 
@@ -211,6 +212,7 @@ def process_edges(diagram, media_path, activity, nodes):
             ):
                 if isinstance(nodes[edge.source], TriccNodeRhombus):
                     edge.source = nodes[edge.source].path.id
+                    edge.source_external_id = None
                 processed = True
             elif label.lower() in (TRICC_YES_LABEL) or label == "":
                 # do nothinbg for yes
@@ -219,7 +221,7 @@ def process_edges(diagram, media_path, activity, nodes):
                 calc = process_factor_edge(edge, nodes)
             elif label.lower() in TRICC_NO_LABEL:
                 calc = process_exclusive_edge(edge, nodes)
-            elif  any(reserved in label.lower() for reserved in ([str(o) for o in list(TriccOperator)] + list(OPERATION_LIST.keys()) + ['$this'])):
+            elif  any(reserved in html2text.html2text(label.lower()) for reserved in ([str(o) for o in list(TriccOperator)] + list(OPERATION_LIST.keys()) + ['$this'])):
                 # manage comment
                 calc = process_condition_edge(edge, nodes)
             else:
@@ -240,6 +242,10 @@ def process_edges(diagram, media_path, activity, nodes):
                         "not management found",
                     )
                 )
+        elif edge.source in  nodes and isinstance(nodes[edge.source], TriccNodeRhombus):
+            logger.critical(
+                "rhombus {} node with labelless edges".format(nodes[edge.source].get_name())
+            )
     if not end_found:
         fake_end = TriccNodeActivityEnd(id=generate_id(f"e{activity.name}"), activity=activity, group=activity)
         last_nodes = [
@@ -974,7 +980,7 @@ def process_exclusive_edge(edge, nodes):
 
 
 def process_yesno_edge(edge, nodes):
-    if edge.value is None:
+    if not edge.value:
         logger.critical(
             "yesNo {} node with labelless edges".format(nodes[edge.source].get_name())
         )

tricc_oo/models/base.py

@@ -112,16 +112,19 @@ class TriccBaseModel(BaseModel):
     version: int = 1
     def get_datatype(self):
         return self.datatype or self.tricc_type
-
+    
+    def get_next_instance(self):
+        if getattr(self, 'instances', None):
+            return max(100, *[n.instance for n in self.instances.values()]) + 1
+        if getattr(self, 'base_instance', None) and getattr(self.base_instance, 'instances', None):
+            return max(100, *[n.instance for n in self.base_instance.instances.values()]) + 1
+        return max(100,self.instance) + 1 
+    
     def to_dict(self):
         return {key: value for key, value in vars(self).items() if not key.startswith('_')}
 
     def make_instance(self, nb_instance, **kwargs):
         instance = self.copy()
-        # change the id to avoid collision of name
-        instance.id = generate_id(f"{self.id}{nb_instance}")
-        instance.instance = int(nb_instance)
-        instance.base_instance = self
         attr_dict = self.to_dict()
         for attr, value in attr_dict.items():
             if not attr.startswith('_') and value is not None:
@@ -132,6 +135,13 @@ class TriccBaseModel(BaseModel):
                         setattr(instance, attr, value)
                 except Exception as e:
                     logger.warning(f"Warning: Could not copy attribute {attr}: {e}")
+        
+        # change the id to avoid collision of name
+        instance.id = generate_id(f"{self.id}{nb_instance}")
+        instance.instance = int(nb_instance)
+        instance.base_instance = self
+        
+        
         # assign the defualt group
         # if activity is not None and self.group == activity.base_instance:
         #    instance.group = instance
@@ -230,20 +240,20 @@ class TriccNodeBaseModel(TriccBaseModel):
     # to be updated while processing because final expression will be possible to build$
     # #only the last time the script will go through the node (all prev node expression would be created    
     def get_name(self):
-        result = str(super().get_name())
+        result = self.__class__.__name__[9:]# str(super().get_name())
         name =  getattr(self, 'name', None) 
         label =  getattr(self, 'label', None)
     
         if name:
-            result = result + "::" + name
+            result += name
         if label:
-            result = result + "::" + (
+            result += "::" + (
                 next(iter(self.label.values())) if isinstance(self.label, Dict) else self.label
             )
-        if len(result) < 50:
+        if len(result) < 80:
             return result
         else:
-            return result[:50]        
+            return result[:80]        
         
 
 
@@ -269,7 +279,7 @@ class TriccNodeBaseModel(TriccBaseModel):
         if self.name is None:
             self.name = get_rand_name(self.id)
     def get_references(self):
-        return OrderedSet([self])
+        return OrderedSet()
 
 class TriccStatic(BaseModel):
     value: Union[str, float, int, bool]
@@ -302,7 +312,7 @@ class TriccStatic(BaseModel):
         return str(self.value)
     
     def __repr__(self):
-        return "TriccStatic:"+str(type(self.value))+':' +str(self.value)
+        return self.__class__.__name__+":"+str(type(self.value))+':' +str(self.value)
 
     def get_references(self):
         return OrderedSet()
@@ -706,17 +716,13 @@ def nand_join(left, right):
     right_issue = right is None or right == ''
     left_neg = left == False or left == 0 or left == '0' or left == TriccStatic(False)
     right_neg = right == False or right == 0 or right == '0' or right == TriccStatic(False)
-    if issubclass(left.__class__, TriccNodeBaseModel):
-        left = get_export_name(left)
-    if issubclass(right.__class__, TriccNodeBaseModel):
-        right = get_export_name(right) 
     if left_issue and right_issue:
         logger.critical("and with both terms empty")
     elif left_issue:
         logger.debug('and with empty left term')
-        return  negate_term(right)
+        return  not_clean(right)
     elif left == '1' or left == 1 or left == TriccStatic(True):
-        return  negate_term(right)
+        return  not_clean(right)
     elif right_issue :
         logger.debug('and with empty right term')
         return  TriccStatic(False)
@@ -725,7 +731,7 @@ def nand_join(left, right):
     elif right_neg:
         return left
     else:
-        return  and_join([left, negate_term(right)])
+        return  and_join([left, not_clean(right)])
 
 
 TriccGroup.update_forward_refs()

tricc_oo/models/tricc.py

@@ -96,7 +96,9 @@ class TriccNodeActivity(TriccNodeBaseModel):
             return self.instances[instance_nb]
         else:
             instance = super().make_instance(instance_nb, activity=None)
-            self.instances[instance_nb] = instance
+            base_instance = (self.base_instance or self)
+            base_instance.instances[instance_nb] = instance
+            instance.base_instance = base_instance
             # instance.base_instance = self
             # we duplicate all the related nodes (not the calculate, duplication is manage in calculate version code)
             nodes = {}
@@ -124,7 +126,7 @@ class TriccNodeActivity(TriccNodeBaseModel):
                 if node in self.calculates and instance_node:
                     instance.calculates.append(instance_node)
             # update parents        
-            for node in list(filter(lambda p_node: hasattr(p_node, 'parent'),list(instance.nodes.values()))):
+            for node in list(filter(lambda p_node: getattr(p_node, 'parent', None) is not None, list(instance.nodes.values()))):
                 new_parent = list(filter(lambda p_node: p_node.base_instance == node.parent,list(instance.nodes.values())))
                 if new_parent:
                     node.parent = new_parent[0]
@@ -179,6 +181,7 @@ class TriccNodeActivity(TriccNodeBaseModel):
             if issubclass(node_instance.__class__, TriccRhombusMixIn):
                 old_path = node_origin.path
                 if old_path is not None:
+                    node_instance.path = None
                     for n in node_instance.activity.nodes.values():
                         if n.base_instance.id == old_path.id:
                             node_instance.path = n

tricc_oo/serializers/xls_form.py

@@ -18,6 +18,9 @@ from tricc_oo.visitors.tricc import (
     add_calculate,
     TRICC_TRUE_VALUE,
     TRICC_FALSE_VALUE,
+    get_applicability_expression,
+    get_prev_instance_skip_expression,
+    get_process_skip_expression,
 )
 
 logger = logging.getLogger("default")
@@ -32,7 +35,7 @@ BOOLEAN_MAP = {
 
 
 def start_group(
-    strategy, cur_group, groups, df_survey, df_calculate, relevance=False, **kwargs
+    strategy, cur_group, groups, df_survey, df_calculate, processed_nodes, process, relevance=False, **kwargs
 ):
     name = get_export_name(cur_group)
 
@@ -46,20 +49,24 @@ def start_group(
     relevance = (
         relevance and cur_group.relevance is not None and cur_group.relevance != ""
     )
+    
 
     group_calc_required = (
         False and relevance and not is_activity and len(relevance) > 100
     )
 
     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 = ""
-    elif isinstance(relevance_expression, TriccOperation):
+    elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
         relevance_expression = strategy.get_tricc_operation_expression(
             relevance_expression
         )
-    elif isinstance(relevance_expression, TriccStatic):
-        relevance_expression = str(relevance_expression.value)
+
 
     # elif is_activity:
     #    relevance_expression = TRICC_CALC_EXPRESSION.format(get_export_name(cur_group.root))
@@ -628,118 +635,3 @@ def get_input_calc_line(node, replace_dots=True):
     ]
 
 
-def get_diagnostic_start_group_line():
-    label = langs.get_trads("List of diagnostics", force_dict=True)
-    empty = langs.get_trads("", force_dict=True)
-    return [
-        "begin group",
-        "l_diag_list25",
-        *list(label.values()),
-        *list(empty.values()),  # hint
-        *list(empty.values()),  # help
-        "",  # default
-        "field-list",  #'appearance',
-        "",  #'constraint',
-        *list(empty.values()),  #'constraint_message'
-        "",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(empty.values()),  #'required message'
-        "",  #'read only'
-        "",  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'
-        "",
-    ]
-
-
-def get_diagnostic_add_line(diags, df_choice):
-    for diag in diags:
-        df_choice.loc[len(df_choice)] = [
-            "tricc_diag_add",
-            get_export_name(diag),
-            *list(langs.get_trads(diag.label, True).values()),
-            "",  # filter
-            "",  # min y
-            "",  # max Y
-            "",  # l
-            "",  # m
-            "",  # s
-        ]
-    label = langs.get_trads("Add a missing diagnostic", force_dict=True)
-    empty = langs.get_trads("", force_dict=True)
-    return [
-        "select_multiple tricc_diag_add",
-        "new_diag",
-        *list(label.values()),
-        *list(empty.values()),  # hint
-        *list(empty.values()),  # help
-        "",  # default
-        "minimal",  #'appearance',
-        "",  #'constraint',
-        *list(empty.values()),  #'constraint_message',
-        "",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(empty.values()),  #'required message'
-        "",  #'read only'
-        "",  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'
-        "",
-    ]
-
-
-def get_diagnostic_none_line(diags):
-    relevance = ""
-    for diag in diags:
-        relevance += TRICC_CALC_EXPRESSION.format(get_export_name(diag)) + " or "
-    label = langs.get_trads(
-        "Aucun diagnostic trouvé par l'outil mais cela ne veut pas dire que le patient est en bonne santé",
-        force_dict=True,
-    )
-    empty = langs.get_trads("", force_dict=True)
-    return [
-        "note",
-        "l_diag_none25",
-        *list(label.values()),
-        *list(empty.values()),
-        *list(empty.values()),
-        "",  # default
-        "",  #'appearance',
-        "",  #'constraint',
-        *list(empty.values()),
-        f"not({relevance[:-4]})",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(empty.values()),
-        "",  #'read only'
-        "",  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'  TRICC_NEGATE
-        "",
-    ]
-
-
-def get_diagnostic_stop_group_line():
-    label = langs.get_trads("", force_dict=True)
-    return [
-        "end group",
-        "l_diag_list25",
-        *list(label.values()),
-        *list(label.values()),
-        *list(label.values()),  # help
-        "",  # default
-        "",  #'appearance',
-        "",  #'constraint',
-        *list(label.values()),
-        "",  #'relevance'
-        "",  #'disabled'
-        "",  #'required'
-        *list(label.values()),
-        "",  #'read only'
-        "",  #'expression'
-        "",  #'repeat_count'
-        "",  #'image'
-        "",
-    ]

tricc_oo/strategies/input/base_input_strategy.py

@@ -73,29 +73,30 @@ class BaseInputStrategy:
             # setting the activity/group to main
             prev_bridge = root
             prev_process = None
-            for process in sorted_pages:
-                nodes = {page.id: page for page in sorted_pages[process]}
-                if prev_process:
-                    prev_bridge = get_activity_wait(
-                        prev_bridge,
-                        sorted_pages[prev_process],
-                        nodes.values(),
-                        activity=app,
-                    )
-                else:
-                    for a in nodes:
-                         set_prev_next_node(
+            for process in self.processes:
+                if process in sorted_pages:
+                    nodes = {page.id: page for page in sorted_pages[process]}
+                    if prev_process:
+                        prev_bridge = get_activity_wait(
                             prev_bridge,
-                            a,
-                            edge_only=True
+                            sorted_pages[prev_process],
+                            nodes.values(),
+                            activity=app,
                         )
-                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
+                    else:
+                        for a in nodes:
+                            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

tricc_oo/strategies/input/drawio.py

@@ -126,8 +126,8 @@ class DrawioStrategy(BaseInputStrategy):
 
         node_edge = list(
             filter(lambda x: (
-                (x.source_external_id and x.source_external_id == node.external_id) or 
                 ( x.source and x.source == node.id) or 
+                (not x.source and x.source_external_id and x.source_external_id == node.external_id) or 
                 x.source == node
             ), page.edges)
         )

tricc_oo/strategies/output/xls_form.py

@@ -85,7 +85,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
 
 
     def clean_coalesce(self, expression):   
-        if re.match(r"^coalesce\(\${[^}]+},''\)$", expression):
+        if re.match(r"^coalesce\(\${[^}]+},''\)$", str(expression)):
             return expression[9:-4]
         return expression
 
@@ -174,8 +174,9 @@ class XLSFormStrategy(BaseOutPutStrategy):
         cur_group = activity
         groups[activity.id] = 0
         path_len = 0
+        process = ['main']
         # keep the vesrions on the group id, max version
-        start_group(self, cur_group=cur_group, groups=groups, **self.get_kwargs())
+        start_group(self, cur_group=cur_group, groups=groups, processed_nodes=processed_nodes, process=process,  **self.get_kwargs())
         walktrhough_tricc_node_processed_stached(
             activity.root,
             self.generate_export,
@@ -183,6 +184,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             stashed_nodes,
             path_len,
             cur_group=activity.root.group,
+            process=process,
             recursive=False,
             **self.get_kwargs()
         )
@@ -218,6 +220,8 @@ class XLSFormStrategy(BaseOutPutStrategy):
                     self,
                     cur_group=s_node.group,
                     groups=groups,
+                    processed_nodes=processed_nodes,
+                    process=process,
                     relevance=True,
                     **self.get_kwargs()
                 )
@@ -314,9 +318,8 @@ class XLSFormStrategy(BaseOutPutStrategy):
                     save_calc = save_calc.iloc[0]
                     if save_calc["name"] != drop_calc["name"]:
                         self.df_survey.replace(
-                            "\$\{" + drop_calc["name"] + "\}",
-                            "\$\{" + save_calc["name"] + "\}",
-                            regex=True,
+                            "${" + drop_calc["name"] + "}",
+                            "${" + save_calc["name"] + "}",
                         )
                 else:
                     logger.critical(
@@ -325,7 +328,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
                         )
                     )
         for index, empty_calc in df_empty_calc.iterrows():
-            self.df_survey.replace("\$\{" + empty_calc["name"] + "\}", "1", regex=True)
+            self.df_survey.replace("${" + empty_calc["name"] + "}", "1", regex=True)
 
         # TODO try to reinject calc to reduce complexity
         for i, c in self.df_calculate[
@@ -334,7 +337,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             real_calc = re.find(r"^number\((.+)\)$", c["calculation"])
             if real_calc is not None and real_calc != "":
                 self.df_survey[~self.df_survey["name"] == c["name"]].replace(
-                    real_calc, "\$\{" + c["name"] + "\}"
+                    real_calc, "${" + c["name"] + "}"
                 )
         
         df_duplicate = self.df_survey[

tricc_oo/strategies/output/xlsform_cdss.py

@@ -1,10 +1,6 @@
 import logging
 from tricc_oo.models.tricc import TriccNodeActivity
 from tricc_oo.models.calculate import TriccNodeProposedDiagnosis, TriccNodeInput
-from tricc_oo.serializers.xls_form import (
-                                        get_diagnostic_none_line,
-                                        get_diagnostic_start_group_line,
-                                        get_diagnostic_stop_group_line)
 from tricc_oo.converters.tricc_to_xls_form import get_export_name
 from tricc_oo.strategies.output.xls_form import XLSFormStrategy
 from tricc_oo.models.lang import SingletonLangClass