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

{tricc_oo-1.4.18 → tricc_oo-1.4.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: tricc-oo
-Version: 1.4.18
+Version: 1.4.20
 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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tricc-oo"
-version = "1.4.18"
+version = "1.4.20"
 description = "Python library that converts CDSS L2 in L3"
 readme = "README.md"
 

{tricc_oo-1.4.18 → tricc_oo-1.4.20}/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)
     
@@ -368,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)
@@ -390,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.18 → tricc_oo-1.4.20}/tricc_oo/converters/drawio_type_map.py

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

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

@@ -112,7 +112,14 @@ class TriccBaseModel(BaseModel):
     version: int = 1
     def get_datatype(self):
         return self.datatype or self.tricc_type
-
+    
+    def get_next_instance(self):
+        if getattr(self, 'instances', None):
+            return max(100, *[n.instance for n in self.instances.values()]) + 1
+        if getattr(self, 'base_instance', None) and getattr(self.base_instance, 'instances', None):
+            return max(100, *[n.instance for n in self.base_instance.instances.values()]) + 1
+        return max(100,self.instance) + 1 
+    
     def to_dict(self):
         return {key: value for key, value in vars(self).items() if not key.startswith('_')}
 
@@ -233,20 +240,20 @@ class TriccNodeBaseModel(TriccBaseModel):
     # to be updated while processing because final expression will be possible to build$
     # #only the last time the script will go through the node (all prev node expression would be created    
     def get_name(self):
-        result = str(super().get_name())
+        result = self.__class__.__name__[9:]# str(super().get_name())
         name =  getattr(self, 'name', None) 
         label =  getattr(self, 'label', None)
     
         if name:
-            result = result + "::" + name
+            result += name
         if label:
-            result = result + "::" + (
+            result += "::" + (
                 next(iter(self.label.values())) if isinstance(self.label, Dict) else self.label
             )
-        if len(result) < 50:
+        if len(result) < 80:
             return result
         else:
-            return result[:50]        
+            return result[:80]        
         
 
 
@@ -305,7 +312,7 @@ class TriccStatic(BaseModel):
         return str(self.value)
     
     def __repr__(self):
-        return "TriccStatic:"+str(type(self.value))+':' +str(self.value)
+        return self.__class__.__name__+":"+str(type(self.value))+':' +str(self.value)
 
     def get_references(self):
         return OrderedSet()

{tricc_oo-1.4.18 → tricc_oo-1.4.20}/tricc_oo/serializers/xls_form.py

@@ -62,12 +62,11 @@ def start_group(
     
     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))

{tricc_oo-1.4.18 → tricc_oo-1.4.20}/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.18 → tricc_oo-1.4.20}/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, 
@@ -945,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(
@@ -1204,6 +1226,7 @@ def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None
         looped = {}
     if waited is None:
         waited = {}
+    all_dependant = OrderedSet()
     for n in loop:
         cur_path = path.copy()
         cur_path.append(n)
@@ -1219,7 +1242,7 @@ def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None
             pass
         for d in dependant:
             if d in path:
-                logger.warning(f"loop {str(d)} already in path {'::'.join(map(path, str))}  ")
+                logger.warning(f"loop {str(d)} already in path {'::'.join(map(str, path))}  ")
             if isinstance(d, TriccNodeSelectOption):
                 d = d.select
             
@@ -1235,9 +1258,10 @@ def get_all_dependant(loop, stashed_nodes, processed_nodes, depth=0, waited=None
                     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(looped, stashed_nodes, processed_nodes, depth+1, waited , looped, path=cur_path)
-
+        waited, looped =  get_all_dependant(all_dependant, stashed_nodes, processed_nodes, depth+1, waited , looped, path=cur_path)
+        
     return waited, looped
 
 
@@ -1468,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,
@@ -1478,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):
@@ -1538,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)
@@ -1625,6 +1651,9 @@ def get_process_skip_expression(node, processed_nodes, process, expression=None)
     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)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.18
+Version: 1.4.20
 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