tricc-oo 1.4.16__tar.gz → 1.4.18__tar.gz

{tricc_oo-1.4.16/tricc_oo.egg-info → tricc_oo-1.4.18}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.3
 Name: tricc-oo
-Version: 1.4.16
+Version: 1.4.18
 Summary: Python library that converts CDSS L2 in L3
 Project-URL: Homepage, https://github.com/SwissTPH/tricc
 Project-URL: Issues, https://github.com/SwissTPH/tricc/issues
@@ -14,6 +14,7 @@ Requires-Dist: markdownify
 Requires-Dist: pydantic
 Requires-Dist: babel
 Requires-Dist: xlsxwriter
+Requires-Dist: html2text
 Requires-Dist: pandas
 Requires-Dist: polib
 Requires-Dist: strenum

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tricc-oo"
-version = "1.4.16"
+version = "1.4.18"
 description = "Python library that converts CDSS L2 in L3"
 readme = "README.md"
 
@@ -19,6 +19,7 @@ dependencies = [
     "pydantic",
     "babel",
     "xlsxwriter",
+    "html2text",
     "pandas",
     "polib",
     "strenum",

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/tricc_oo/converters/cql_to_operation.py

@@ -150,6 +150,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))

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/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:

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/tricc_oo/models/base.py

@@ -118,10 +118,6 @@ class TriccBaseModel(BaseModel):
 
     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 +128,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
@@ -269,7 +272,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]
@@ -706,17 +709,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 +724,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-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/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,12 +49,17 @@ 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):
@@ -628,118 +636,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-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/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-1.4.16 → tricc_oo-1.4.18}/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

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/tricc_oo/visitors/tricc.py

@@ -657,7 +657,7 @@ def process_operation_reference(operation, node, processed_nodes, calculates, us
             if codesystems:
                 concept =  lookup_codesystems_code(codesystems, ref)
                 if not concept:
-                    logger.critical(f"reference {ref} not found in the project")
+                    logger.critical(f"reference {ref} not found in the project for{str(node)} ")
                     exit(1)
                 else:
                     if warn:
@@ -768,7 +768,13 @@ def walktrhough_tricc_node_processed_stached(node, callback, processed_nodes, st
         references = node.get_references()
         if references:
             path_len = max(path_len, *[0,*[getattr(n,'path_len',0) + 1 for n in references]])
-    node.path_len = max(node.path_len, path_len)    
+    node.path_len = max(node.path_len, path_len)
+    prev_process = process[0] if process else None
+    if isinstance(node, TriccNodeActivity) and getattr(node.root, 'process', None):
+        if process is None:
+            process = [node.root.process]
+        else:
+            process[0] = node.root.process
     if (
         callback(
             node, 
@@ -802,11 +808,6 @@ def walktrhough_tricc_node_processed_stached(node, callback, processed_nodes, st
         if not recursive:
             reorder_node_list(stashed_nodes, node.group, processed_nodes)
         if isinstance(node, (TriccNodeActivityStart, TriccNodeMainStart)):
-            if getattr(node, 'process', None):
-                if process is None:
-                    process = [node.process]
-                else:
-                    process[0] = node.process
             if recursive:
                 for gp in node.activity.groups.values():
                     walktrhough_tricc_node_processed_stached(
@@ -851,11 +852,6 @@ def walktrhough_tricc_node_processed_stached(node, callback, processed_nodes, st
             if node.root not in processed_nodes:
                 if node.root is not None:
                     node.root.path_len = max(path_len,  node.root.path_len)
-                    if getattr(node.root, 'process', None):
-                        if process is None:
-                            process = [node.root.process]
-                        else:
-                            process[0] = node.root.process
                     if recursive:
                         walktrhough_tricc_node_processed_stached(node.root, callback, processed_nodes, stashed_nodes, path_len,
                                                             recursive, warn = warn,node_path = node_path.copy(),**kwargs)
@@ -897,6 +893,8 @@ def walktrhough_tricc_node_processed_stached(node, callback, processed_nodes, st
         
                 
     else:
+        if prev_process and process and prev_process != process[0]:
+            process[0] = prev_process
         if node not in processed_nodes and node not in stashed_nodes:
             if node not in stashed_nodes:
                 stashed_nodes.insert_at_bottom(node)
@@ -1146,23 +1144,34 @@ def check_stashed_loop(stashed_nodes, prev_stashed_nodes, processed_nodes, len_p
                             es_node.activity.instance if hasattr(es_node,'activity') else '',
                             es_node.__class__, 
                             es_node.get_name()))
+                    for es_node in [node for node_list in looped.values() for node in node_list if isinstance(node, TriccReference)]:
+                        logger.info("looped node {}:{}|{} {}".format(
+                            es_node.activity.get_name() if hasattr(es_node,'activity') else '' ,
+                            es_node.activity.instance if hasattr(es_node,'activity') else '',
+                            es_node.__class__, 
+                            es_node.get_name()))
+                    for es_node in [node for node_list in waited.values() for node in node_list if isinstance(node, TriccReference)]:
+                        logger.info("waited node {}:{}|{} {}".format(
+                            es_node.activity.get_name() if hasattr(es_node,'activity') else '' ,
+                            es_node.activity.instance if hasattr(es_node,'activity') else '',
+                            es_node.__class__, 
+                            es_node.get_name()))
                     logger.info("looped nodes")
                     for dep_list in looped:
                         for d in looped[dep_list]:
-                            if d.get_name() == dep_list:
-                                logger.critical("[{}] depends on itself".format(
-                                    dep_list, 
+                            if str(d) in looped:
+                                logger.critical("[{}] depends on [{}]".format(
+                                    dep_list, str(d)
+                                    ))
+                            else:
+                                logger.error("[{}] depends on [{}]".format(
+                                    dep_list, str(d)
                                     ))
-                            logger.error("[{}] depends on [{}]".format(
-                                dep_list, str(d)
-                                ))
                         if dep_list in waited:
                             for d in waited[dep_list]:
                                 logger.warning("[{}] depends on [{}]".format(
                                     dep_list, str(d)
                                     ))
-                        
-                        #reverse_walkthrough(es_node, es_node, print_trace, processed_nodes, stashed_nodes)
                     logger.info("waited nodes")
                     for dep_list in waited:
                         if dep_list not in looped:
@@ -1179,7 +1188,6 @@ def check_stashed_loop(stashed_nodes, prev_stashed_nodes, processed_nodes, len_p
         loop_count = 0
     return loop_count
 
-
 def add_to_tree(tree, n, d):
     n_str = str(n)
     if n_str not in tree:
@@ -1189,12 +1197,16 @@ def add_to_tree(tree, n, d):
     return tree
 
         
-def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None , looped=None):
+def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None , looped=None, path = None):
+    if path is None:
+        path =[] 
     if looped is None:
         looped = {}
     if waited is None:
         waited = {}
     for n in loop:
+        cur_path = path.copy()
+        cur_path.append(n)
         dependant = OrderedSet()
         i=0
         #logger.critical(f"{i}: {n.__class__}::{n.get_name()}::{getattr(n,'instance','')}::{process_reference(n, processed_nodes, [])}")
@@ -1206,28 +1218,30 @@ def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None
         if not isinstance(dependant, list):
             pass
         for d in dependant:
+            if d in path:
+                logger.warning(f"loop {str(d)} already in path {'::'.join(map(path, str))}  ")
             if isinstance(d, TriccNodeSelectOption):
                 d = d.select
-            if d not in waited and d not in looped:
-                if isinstance(d, TriccReference):
-                    if not any(n.name == d.value for n in processed_nodes):
-                        if not any(n.name == d.value for n in stashed_nodes):
-                            waited = add_to_tree(waited, n, d) 
-                        else :
-                            looped = add_to_tree(looped, n, d)
-                
-                elif d  not in processed_nodes:
-                    if d in stashed_nodes:
-                        looped = add_to_tree(looped, n, d) 
+            
+            if isinstance(d, TriccReference):
+                if not any(n.name == d.value for n in processed_nodes):
+                    if not any(n.name == d.value for n in stashed_nodes):
+                        waited = add_to_tree(waited, n, d)
                     else :
-                        waited = add_to_tree(waited, n, d) 
+                        looped = add_to_tree(looped, n, d)
+            
+            elif d not in processed_nodes:
+                if d in stashed_nodes:
+                    looped = add_to_tree(looped, n, d)
+                else :
+                    waited = add_to_tree(waited, n, d)
     if depth < MAX_DRILL:
-        return get_all_dependant(waited, stashed_nodes, processed_nodes, depth+1, waited , looped)
+        return get_all_dependant(looped, stashed_nodes, processed_nodes, depth+1, waited , looped, path=cur_path)
 
     return waited, looped
 
 
-MAX_DRILL = 1
+MAX_DRILL = 3
 
 def get_last_end_node(processed_nodes, process=None):
     end_name = 'tricc_end_'
@@ -1550,61 +1564,10 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
     if expression is None:
         expression = get_prev_node_expression(node, processed_nodes=processed_nodes, is_calculate=is_calculate, process=process)
             # in_node not in processed_nodes is need for calculates that can but run after the end of the activity
-
-    
-    if isinstance(node, TriccNodeActivity):
-        
-        
-        if node.base_instance is not None and not is_prev:
-            activity = node
-            expression_inputs = []
-            past_instances = [
-                n for n in processed_nodes if getattr(n.base_instance, 'id', None) == node.base_instance.id
-            ]
-            for past_instance in past_instances:
-                add_sub_expression(
-                    expression_inputs, 
-                    get_node_expression(
-                        past_instance,
-                        processed_nodes=processed_nodes,
-                        is_calculate=False,
-                        is_prev=True,
-                        process=process
-                    )
-                )
-            
-            if isinstance(node.applicability,(TriccStatic,TriccOperation, TriccReference)):
-                if expression:
-                    expression = and_join([node.applicability, expression])
-                else:
-                    expression = node.applicability
-            if expression and expression_inputs:
-                add_sub_expression(expression_inputs, expression)
-                expression = nand_join(expression, or_join(expression_inputs))
-            elif expression_inputs:
-                expression =  negate_term(or_join(expression_inputs))
-        if not is_prev:
-            end_expressions = []
-            f_end_expression = get_end_expression(processed_nodes)
-            if f_end_expression:
-                end_expressions.append(f_end_expression)
-            if process[0] in PROCESSES:
-                for p in PROCESSES[PROCESSES.index(process[0])+1:]:
-                    p_end_expression = get_end_expression(processed_nodes, p)
-                    if p_end_expression:
-                        end_expressions.append(p_end_expression)
-            if node.applicability:
-                end_expressions.append(node.applicability)
-            if end_expressions:
-                if expression:
-                    end_expressions.append(expression)
-                if len(end_expressions) == 1:
-                    expression = end_expressions[0]
-                else:
-                    expression = and_join(end_expressions)
-                    
-            
-                
+    #if isinstance(node, TriccNodeActivitiy) and not prev:
+        # expression = get_applicability_expression(node, processed_nodes, process, expression)
+        # expression = get_prev_instance_skip_expression(node, processed_nodes, process, expression)
+        # expression = get_process_skip_expression(node, processed_nodes, process, expression)
     if negate:
         if negate_expression is not None:
             return negate_expression
@@ -1615,7 +1578,67 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
             # exit(1)
     else:
         return expression
+    
+def get_applicability_expression(node, processed_nodes, process, expression=None):
+    if isinstance(node.applicability,(TriccStatic,TriccOperation, TriccReference)):
+        if expression:
+            expression = and_join([node.applicability, expression])
+        else:
+            expression = node.applicability
+    
+    return expression
+    
 
+
+        
+        
+def get_prev_instance_skip_expression(node, processed_nodes, process, expression=None):
+    if node.base_instance is not None:
+        activity = node
+        expression_inputs = []
+        past_instances = [
+            n for n in processed_nodes if getattr(n.base_instance, 'id', None) == node.base_instance.id
+        ]
+        for past_instance in past_instances:
+            add_sub_expression(
+                expression_inputs, 
+                get_node_expression(
+                    past_instance,
+                    processed_nodes=processed_nodes,
+                    is_calculate=False,
+                    is_prev=True,
+                    process=process
+                )
+            )
+        if expression and expression_inputs:
+            add_sub_expression(expression_inputs, expression)
+            expression = nand_join(expression, or_join(expression_inputs))
+        elif expression_inputs:
+            expression =  negate_term(or_join(expression_inputs))
+    return expression
+
+
+# end def
+def get_process_skip_expression(node, processed_nodes, process, expression=None):
+    
+    end_expressions = []
+    f_end_expression = get_end_expression(processed_nodes)
+    if f_end_expression:
+        end_expressions.append(f_end_expression)
+    if process[0] in PROCESSES:
+        for p in PROCESSES[PROCESSES.index(process[0])+1:]:
+            p_end_expression = get_end_expression(processed_nodes, p)
+            if p_end_expression:
+                end_expressions.append(p_end_expression)
+    if end_expressions:
+        if expression:
+            end_expressions.append(expression)
+        if len(end_expressions) == 1:
+            expression = end_expressions[0]
+        else:
+            expression = and_join(end_expressions)
+    return expression
+        
 def get_end_expression(processed_nodes, process=None):
     end_node = get_last_end_node(processed_nodes, process)
     if end_node:
@@ -2033,7 +2056,7 @@ def get_rhombus_terms( node, processed_nodes, is_calculate=False, negate=False,
                 ]
             )
         else:
-            if left_term is not None and re.search(" (\+)|(\-)|(or)|(and) ", expression):
+            if left_term is not None and re.search(" (+)|(-)|(or)|(and) ", expression):
                 expression = "({0}){1}".format(expression, left_term)
             else:
                 expression = "{0}{1}".format(expression, left_term)

{tricc_oo-1.4.16 → tricc_oo-1.4.18/tricc_oo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.16
+Version: 1.4.18
 Summary: Python library that converts CDSS L2 in L3
 Project-URL: Homepage, https://github.com/SwissTPH/tricc
 Project-URL: Issues, https://github.com/SwissTPH/tricc/issues
@@ -14,6 +14,7 @@ Requires-Dist: markdownify
 Requires-Dist: pydantic
 Requires-Dist: babel
 Requires-Dist: xlsxwriter
+Requires-Dist: html2text
 Requires-Dist: pandas
 Requires-Dist: polib
 Requires-Dist: strenum

{tricc_oo-1.4.16 → tricc_oo-1.4.18}/tricc_oo.egg-info/requires.txt

@@ -3,6 +3,7 @@ markdownify
 pydantic
 babel
 xlsxwriter
+html2text
 pandas
 polib
 strenum