tricc-oo 1.4.15__py3-none-any.whl → 1.4.21__py3-none-any.whl

tricc_oo/visitors/tricc.py

@@ -93,6 +93,81 @@ def get_node_expressions(node, processed_nodes, process=None):
         expression = TriccStatic(True)
     return expression
 
+def set_last_version_false(node, processed_nodes):
+    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 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
+        node.path_len = max(node.path_len, last_version.path_len + 1)
+    return last_version
+        
+def get_version_inheritance(node, last_version, processed_nodes):
+        # FIXME this is for XLS form where only calculate are evaluated for a activity that is not triggered
+        if not issubclass(node.__class__, (TriccNodeInputModel)):
+            node.last = True
+            if (
+                issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeEnd)) and node.name is not None
+            ):
+                #logger.debug("set last to false for node {}  and add its link it to next one".format(last_used_calc.get_name()))
+                if node.prev_nodes:    
+                    set_prev_next_node(last_version, node)
+                else:
+                    expression = node.expression or node.expression_reference or getattr(node, 'relevance', None)
+                    datatype = expression.get_datatype()
+                    if datatype == 'boolean':
+                        expression_reference = TriccOperation(
+                            TriccOperator.OR,
+                            [TriccOperation(TriccOperator.ISTRUE, [last_version]), expression]
+                        )
+                    
+                    elif datatype == 'number':
+                        expression = TriccOperation(
+                            TriccOperator.PLUS,
+                            [last_version, expression] 
+                        )
+                    else:
+                        expression = TriccOperation(
+                            TriccOperator.COALESCE,
+                            [last_version, expression] 
+                        )
+                    if node.expression:
+                        node.expression = expression
+                    elif node.expression_reference:
+                        node.expression_reference = expression
+                    elif node.relevance:
+                        node.relevance = expression
+        else:
+            node.last = False
+            
+            
+            calc = TriccNodeCalculate(
+                id=generate_id(f"save{node.id}"),
+                name=node.name,
+                path_len=node.path_len+1,
+                version=get_next_version(node.name, processed_nodes, node.version+2),
+                expression=TriccOperation(
+                    TriccOperator.COALESCE,
+                    [node, last_version, TriccStatic("''")]
+                ),
+                last=True,
+                activity=node.activity,
+                group=node.group
+                )
+            node.activity.nodes[calc.id]=calc
+            node.activity.calculates.append(calc)
+            set_last_version_false(calc, processed_nodes)
+            processed_nodes.add(calc)
+            if issubclass(node.__class__, TriccNodeInputModel):
+                node.expression = TriccOperation(
+                    TriccOperator.COALESCE,
+                    [
+                        '$this',
+                        last_version
+                    ]
+                )
 
 def process_calculate(node,processed_nodes, stashed_nodes, calculates, used_calculates, 
                       warn = False, process=None, **kwargs ):
@@ -117,76 +192,11 @@ def process_calculate(node,processed_nodes, stashed_nodes, calculates, used_calc
         ):
             if kwargs.get('warn', True):
                 logger.debug('Processing relevance for node {0}'.format(node.get_name()))
-            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)
+            last_version =  set_last_version_false(node, processed_nodes)
             if last_version:
-                # 0-100 for manually specified instance.  100-200 for auto instance 
-                node.version = last_version.version + 1
-                last_version.last = False
-                node.path_len = max(node.path_len, last_version.path_len + 1)
-                # FIXME this is for XLS form where only calculate are evaluated for a activity that is not triggered
-                if not issubclass(node.__class__, (TriccNodeInputModel)):
-                    node.last = True
-                    if (
-                        issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeEnd)) and node.name is not None
-                    ):
-                        #logger.debug("set last to false for node {}  and add its link it to next one".format(last_used_calc.get_name()))
-                        if node.prev_nodes:    
-                            set_prev_next_node(last_version, node)
-                        else:
-                            expression = node.expression or node.expression_reference or node.relevance
-                            datatype = expression.get_datatype()
-                            if datatype == 'boolean':
-                                expression_reference = TriccOperation(
-                                    TriccOperator.OR,
-                                    [TriccOperation(TriccOperator.ISTRUE, [last_version]), expression]
-                                )
-                            
-                            elif datatype == 'number':
-                                expression = TriccOperation(
-                                    TriccOperator.PLUS,
-                                    [last_version, expression] 
-                                )
-                            else:
-                                expression = TriccOperation(
-                                    TriccOperator.COALESCE,
-                                    [last_version, expression] 
-                                )
-                            if node.expression:
-                                node.expression = expression
-                            elif node.expression_reference:
-                                node.expression_reference = expression
-                            elif node.relevance:
-                                node.relevance = expression
-                else:
-                    node.last = False
-                    
-                    
-                    calc = TriccNodeCalculate(
-                        id=generate_id(f"save{node.id}"),
-                        name=node.name,
-                        path_len=node.path_len+1,
-                        version=last_version.version + 2,
-                        expression=TriccOperation(
-                            TriccOperator.COALESCE,
-                            [node, last_version, TriccStatic("''")]
-                        ),
-                        last=True,
-                        activity=node.activity,
-                        group=node.group
-                        )
-                    node.activity.nodes[calc.id]=calc
-                    node.activity.calculates.append(calc)
-                    if issubclass(node.__class__, TriccNodeInputModel):
-                        node.expression = TriccOperation(
-                            TriccOperator.COALESCE,
-                            [
-                                '$this',
-                                last_version
-                            ]
-                        )
-                    
+                last_version = get_version_inheritance(node, last_version, processed_nodes)
+            generate_calculates(node,calculates, used_calculates,processed_nodes=processed_nodes)                
+       
                 
 
         # if has prev, create condition
@@ -218,7 +228,6 @@ def process_calculate(node,processed_nodes, stashed_nodes, calculates, used_calc
                         if issubclass(r.__class__, (TriccNodeDisplayCalculateBase )):
                             add_used_calculate(node, r, calculates, used_calculates, processed_nodes)
                 
-                generate_calculates(node,calculates, used_calculates,processed_nodes=processed_nodes)                
             if last_version and hasattr(node, 'relevance'):
                 if isinstance(node, TriccNodeInputModel):
                     version_relevance =  TriccOperation(
@@ -468,16 +477,23 @@ def generate_calculates(node,calculates, used_calculates,processed_nodes):
             calc_node.path_len += 1
             calc_node.name=calculate_name
             calc_node.label =  "save select: " +node.get_name()        
-        else:
+        elif node.name != calculate_name:
             calc_id = generate_id(f"autosave{node.id}")
+            
             calc_node = TriccNodeCalculate(
                 name=calculate_name,
                 id = calc_id,
                 group = node.group,
+                version=get_next_version(calculate_name, processed_nodes, node.version+2),
                 activity = node.activity,
                 label =  "save: " +node.get_name(),
-                path_len=node.path_len+ 1
+                path_len=node.path_len+ 1,
+                last=True
             )
+            node.activity.nodes[calc_node.id]=calc_node
+            node.activity.calculates.append(calc_node)
+            set_last_version_false(calc_node, processed_nodes)
+            processed_nodes.add(calc_node)
         logger.debug("generate_save_calculate:{}:{} as {}".format(calc_node.tricc_type, node.name if hasattr(node,'name') else node.id, calculate_name))
         if isinstance(node, TriccNodeSelectYesNo):
             yesNode =  node.options[0]
@@ -526,12 +542,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 +676,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 +787,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 +827,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 +871,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 +912,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)
@@ -947,6 +964,9 @@ def walkthrough_tricc_option(node, callback, processed_nodes, stashed_nodes, pat
                                                                         warn = warn,
                                                                         node_path = node_path.copy(), **kwargs)
 
+def get_next_version(name, processed_nodes, version=0,):
+    return max(version, 100,*[(getattr(n,'version',0) or getattr(n,'instance',0) or 0) for n in get_versions(name, processed_nodes)])
+
 
 def get_data_for_log(node):
     return "{}:{}|{} {}:{}".format(
@@ -1146,23 +1166,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 +1210,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 +1219,17 @@ 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 = {}
+    all_dependant = OrderedSet()
     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 +1241,31 @@ 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(str, path))}  ")
             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)
+            all_dependant = all_dependant.union(dependant)
     if depth < MAX_DRILL:
-        return get_all_dependant(waited, stashed_nodes, processed_nodes, depth+1, waited , looped)
-
+        waited, looped =  get_all_dependant(all_dependant, 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_'
@@ -1454,7 +1492,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,
@@ -1464,7 +1502,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):
@@ -1524,7 +1564,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)
@@ -1550,61 +1590,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 +1604,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:
@@ -1686,9 +1738,10 @@ def get_select_accept_reject_options(node, group):
     return {0:yes, 1:no }
 
 def create_determine_diagnosis_activity(diags):
-    start = TriccNodeActivityStart(
+    start = TriccNodeMainStart(
         id=generate_id('start.determine-diagnosis'),
-        name="start.determine-diagnosis"
+        name="start.determine-diagnosis",
+        process='determine-diagnosis'
     )
 
     
@@ -2032,7 +2085,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.15.dist-info → tricc_oo-1.4.21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.15
+Version: 1.4.21
 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.15.dist-info → tricc_oo-1.4.21.dist-info}/RECORD

@@ -1,46 +1,46 @@
-tests/build.py,sha256=Wo2-JLEhsUSva8EanX5aRTS-tddqQWmBH-hwapotw1M,6478
+tests/build.py,sha256=aGpylfQU60xPq0AJX-UQQRIxXd7Nxb7SLulVEfZt3aA,6483
 tests/test_cql.py,sha256=sxAYEtiiZ-naXVaKPDYHaQFVhbw0QnYy4_MCItgv1Do,6547
 tests/to_ocl.py,sha256=f_KeKF7N1tri9ChbtH1OShgHskt_T9Wj1IfaT6qJNGY,2247
 tricc_oo/__init__.py,sha256=Els6sDXpOJiGU1zp45rTXZgEKceq_XhRZDfrx1mIMGc,255
 tricc_oo/converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/converters/codesystem_to_ocl.py,sha256=-ZKMBeIvzgqmhJfnn6ptuwpnHQtuE-fCDDfKpfGvUSU,6066
-tricc_oo/converters/cql_to_operation.py,sha256=TrZLfNRtLpcpHM1L524IQvv-hnWaksmrxWie0iMvFKM,13609
-tricc_oo/converters/datadictionnary.py,sha256=WQCvMYgEcxoCL1nRqq2aCQszIaKrIPCe3CkkZ0reAyY,3824
-tricc_oo/converters/drawio_type_map.py,sha256=HQR9fzwy52BRL0pWhYftzrRBd3LLWP4Ot1_CIqA8mCM,7011
-tricc_oo/converters/tricc_to_xls_form.py,sha256=bIVP1J2eZyIiVTaGQ3oQ_yu18R0stb4abMxg4fWr9Zc,2137
+tricc_oo/converters/cql_to_operation.py,sha256=bsVD4HO5Zr2clHuIWz86gIUnI7aZ676IXDK5S7x32_o,14439
+tricc_oo/converters/datadictionnary.py,sha256=WWKcTtKLfc4aduHcDBhr4JSfU2NqRMaslwX-wdZPIAw,3968
+tricc_oo/converters/drawio_type_map.py,sha256=6ZcnQMtBU1dhf_NP_s0iX1DvRf0qS7-3UAe_WAPFVoQ,7027
+tricc_oo/converters/tricc_to_xls_form.py,sha256=TKClvHSi07AxncjS8H_d17eXQIcLX4lNZr2fSj62p4Y,2129
 tricc_oo/converters/utils.py,sha256=UyndDORsDbRV5-gYW-yInK5ztjtYdeCw6K-mrYr1Emk,1688
-tricc_oo/converters/xml_to_tricc.py,sha256=SfOgqgy8lYO08Q7JfCPCTKWbzwr6hURGD7ULZgqMLtc,37147
+tricc_oo/converters/xml_to_tricc.py,sha256=9ujnPrCU0xyxrt06SmVT-2LGbS1XXeYyFkZX785BECg,37236
 tricc_oo/converters/cql/cqlLexer.py,sha256=t0-QvDv5kxCiBZJ9SfDumFOgnRSry_HJpakBZV224Ig,49126
 tricc_oo/converters/cql/cqlListener.py,sha256=ketvj7XvO7t047S6A3_gTPvp2MlYk1bojmkl10v5E6Y,57523
 tricc_oo/converters/cql/cqlParser.py,sha256=hIUdR907WX24P2Jlrxk-H0IT94n51yh_ZsCmwQhnFas,414730
 tricc_oo/converters/cql/cqlVisitor.py,sha256=SWSDIqVYBhucR4VgLn_EPNs7LV9yCqsOmzFZ0bmRSGc,33865
 tricc_oo/models/__init__.py,sha256=Rdk1fsNXHrbmXTQD1O7i0NC_A6os648Ap6CtWRliOg8,92
-tricc_oo/models/base.py,sha256=kAQuZtOsFtwX3V84zePgW9Pc-RYiny4EsnBlLecr3Yw,24059
+tricc_oo/models/base.py,sha256=RE4J98-zzKcB5a0gm4EPjbMjcHEuM17lkIMRAxUPtyQ,24309
 tricc_oo/models/calculate.py,sha256=Bw7OGa4OYxHP529wA23CZftMYDL_CA0SPQ0j1IFyTNA,7456
 tricc_oo/models/lang.py,sha256=SwKaoxyRhE7gH_ZlYyFXzGuTQ5RE19y47LWAA35zYxg,2338
 tricc_oo/models/ocl.py,sha256=ol35Gl1jCBp0Ven0yxOKzDIZkVL5Kx9uwaR_64pjxKI,8931
 tricc_oo/models/ordered_set.py,sha256=cdvqlWgbwN0Jl7btssEoXbzQJ2rlMzxGILRblMqjRg0,4182
-tricc_oo/models/tricc.py,sha256=FG8rq7zy3vbZO1C6WofMq--FE0JErdysM9WfAj4YYns,16321
+tricc_oo/models/tricc.py,sha256=kzOjlHXmXZ2syk-cvDDxi3HPG-ZL38Y--drip3RjjBM,16503
 tricc_oo/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/parsers/xml.py,sha256=vq9PA5Zt4G3QMtZ1zgyN8110O1w19Jqt6JClJYhHJlU,4410
 tricc_oo/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/serializers/planuml.py,sha256=a81YKsjgng-h2H_rmFE2J5FeBBUaH8kRGT8YrvzpEKE,455
-tricc_oo/serializers/xls_form.py,sha256=-4ktvS1Kjk_WDZb2nry_VMjpV7ju3LZHwfsCIFAd8Uw,25618
+tricc_oo/serializers/xls_form.py,sha256=oaBfHGJ_I_7qAPuxdG361PCaEKo1TD1LUvHJvo0kYlk,22707
 tricc_oo/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tricc_oo/strategies/input/base_input_strategy.py,sha256=dag8NVIuNXFtpptXrL-fGpPbIMF7gwYMtrVt9kL_iu0,3962
-tricc_oo/strategies/input/drawio.py,sha256=lWj5DYFxe4WpcpyrmVjy9S8_ubNG4rHxYBIp1cWzZaU,13345
+tricc_oo/strategies/input/base_input_strategy.py,sha256=-GQ_xRvJXzn-q_eT8R-wtFOTWzPtdNj79zjmsH6x070,4065
+tricc_oo/strategies/input/drawio.py,sha256=glLts9whixJM4HOV_GAWAK8az_H-eo9aeFAQbn99-4c,13362
 tricc_oo/strategies/output/base_output_strategy.py,sha256=WiJwqm4g_x-rbksrjoE0ABhNMtM0_fAMoPH34RKZdc0,7173
 tricc_oo/strategies/output/spice.py,sha256=s_COahyYCoc4Xv5TGh_AW9evDOW6GOex0Xwa_JWeLsI,11280
-tricc_oo/strategies/output/xls_form.py,sha256=2sJhyy2BQXpekjxGptBywh-2kwILnLYEUFx2MoOIkx4,30531
-tricc_oo/strategies/output/xlsform_cdss.py,sha256=dAT4KkXpoV8-PH7ya7aSa_86__YG0hElHss9VJoyVR8,9707
-tricc_oo/strategies/output/xlsform_cht.py,sha256=tHayxmFFM1_7Xu-Huz-IjvteEQXQm2fhKwAMFtG-tjU,17472
-tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=bRTga6vteU86YWJC3umWeaL6Lt9dDz6e4pnHu7ctOiI,12377
+tricc_oo/strategies/output/xls_form.py,sha256=dsKbAdzjqgJGXNWrMuqzNAsTNO9EXh3g-QJNegz-gpY,30681
+tricc_oo/strategies/output/xlsform_cdss.py,sha256=8oLlgS1Hr6IVvI0O71kIk5oIKXbt2lPVc1SZIjzcSTc,9452
+tricc_oo/strategies/output/xlsform_cht.py,sha256=QLMBjxrCl8USBtZ0YarhU7RgY8gWT_s1WtPgfzBpXwk,19465
+tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=DEc8T62L17FSC-HJaFQacciQdaDa2MPK7lZpSatQIHs,2200
 tricc_oo/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tricc_oo/visitors/tricc.py,sha256=-nrFmTxN0cdBbENtk0VitIBp2SamrMAMby9xHfvVwXI,95312
+tricc_oo/visitors/tricc.py,sha256=R9XWBskDAfkA0NbEo0ammkHsDASFgkthPDWOiOaLgbQ,97643
 tricc_oo/visitors/utils.py,sha256=Gol4JNozPEd30Q1l8IPIPhx5fqVyy9R81GofGVebgD8,484
 tricc_oo/visitors/xform_pd.py,sha256=H8x-72EdyT_-QgHGQN-ZAe-wc7tLtJGCM9waA64mz3M,9424
-tricc_oo-1.4.15.dist-info/METADATA,sha256=JUvJmxvWBba3RxbzVJIp9PCe5rMpMFFgIJkF-Jitark,7853
-tricc_oo-1.4.15.dist-info/WHEEL,sha256=ooBFpIzZCPdw3uqIQsOo4qqbA4ZRPxHnOH7peeONza0,91
-tricc_oo-1.4.15.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.4.15.dist-info/RECORD,,
+tricc_oo-1.4.21.dist-info/METADATA,sha256=vOGzsW7gtsMKnNJx9vY7W5a55tSENg1Vz1vM1hjTZVg,7878
+tricc_oo-1.4.21.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+tricc_oo-1.4.21.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.4.21.dist-info/RECORD,,