tricc-oo 1.4.17__tar.gz → 1.4.19__tar.gz

{tricc_oo-1.4.17 → tricc_oo-1.4.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tricc-oo
-Version: 1.4.17
+Version: 1.4.19
 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.17 → tricc_oo-1.4.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tricc-oo"
-version = "1.4.17"
+version = "1.4.19"
 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.17 → tricc_oo-1.4.19}/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-1.4.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/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]
@@ -302,7 +305,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 +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.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/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-1.4.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/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.17 → tricc_oo-1.4.19}/tricc_oo/strategies/output/xlsform_cht.py

@@ -117,7 +117,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         # pause
         ends = []
         for p in self.project.pages.values():
-            p_ends = list(filter(lambda x:  issubclass(x.__class__, TriccNodeEnd) and getattr(x, 'hint', None) is not None, p.nodes.values() ))
+            p_ends = list(filter(lambda x:  issubclass(x.__class__, TriccNodeEnd) and getattr(x, 'process', '') == 'pause', p.nodes.values() ))
             if p_ends:
                 ends += p_ends
         if ends:

{tricc_oo-1.4.17 → tricc_oo-1.4.19}/tricc_oo/visitors/tricc.py

@@ -120,7 +120,7 @@ def process_calculate(node,processed_nodes, stashed_nodes, calculates, used_calc
             node_name = node.name if not isinstance(node, TriccNodeEnd) else node.get_reference()
             last_version = get_last_version(node_name, processed_nodes) if issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)) and not isinstance(node, TriccNodeSelectOption)  else  None
             #last_version = processed_nodes.find_prev(node, lambda item: hasattr(item, 'name') and item.name == node.name)
-            if last_version:
+            if last_version and getattr(node, 'process', '') != 'pause':
                 # 0-100 for manually specified instance.  100-200 for auto instance 
                 node.version = last_version.version + 1
                 last_version.last = False
@@ -526,12 +526,15 @@ def process_reference(node, processed_nodes, calculates, used_calculates=None,
             node.reference = list(modified_expression.get_references())
             node.expression_reference = modified_expression
     elif getattr(node, 'reference', None):
-        if isinstance(node.reference, list):
+        reference = node.reference
+        if isinstance(reference, list):
+            if isinstance(node, TriccNodeWait):
+                reference = [TriccOperation(TriccOperator.ISTRUE,[n]) for n in reference]
             if len(node.reference) == 1 :
-                operation = node.reference[0]
+                operation = reference[0]
             else:
                 operation = and_join(
-                        node.reference
+                        reference
                     )
             modified_expression = process_operation_reference(
                 operation, 
@@ -657,7 +660,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:
@@ -1144,23 +1147,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:
@@ -1177,7 +1191,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:
@@ -1187,12 +1200,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, [])}")
@@ -1204,28 +1221,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_'
@@ -1452,7 +1471,7 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
     expression = None
     negate_expression = None
     node = in_node
-    if isinstance(node, (TriccNodeActivityStart,TriccNodeMainStart, TriccNodeActivityEnd)):
+    if isinstance(node, (TriccNodeActivityStart,TriccNodeMainStart)):
         if is_prev and is_calculate:
             expression = get_node_expression(
                 node.activity,
@@ -1462,7 +1481,9 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
                 negate=negate,
                 process=process
             )
-        elif  isinstance(node, (TriccNodeActivityStart)):
+            if isinstance(node, TriccNodeMainStart):
+                expression =  get_applicability_expression(node.activity, processed_nodes, process, expression )
+        elif isinstance(node, (TriccNodeActivityStart)):
             return None
         
     elif isinstance(node, TriccNodeWait):
@@ -1522,7 +1543,7 @@ def get_node_expression( in_node, processed_nodes, is_calculate=False, is_prev=F
         # else:    
         expression = node.expression_reference
     elif not is_prev and hasattr(node, 'relevance') and isinstance(node.relevance, TriccOperation):
-        expression = node.relevance  
+        expression = node.relevance     
     elif is_prev and isinstance(node, TriccNodeSelectOption):
         if negate:
             negate_expression = get_selected_option_expression(node, negate)
@@ -1548,61 +1569,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
@@ -1613,7 +1583,70 @@ 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)
+    b_end_expression = get_end_expression(processed_nodes, 'pause')
+    if b_end_expression:
+        end_expressions.append(b_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:

{tricc_oo-1.4.17 → tricc_oo-1.4.19}/tricc_oo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.17
+Version: 1.4.19
 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.17 → tricc_oo-1.4.19}/tricc_oo.egg-info/requires.txt

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