tricc-oo 1.4.23__tar.gz → 1.4.24__tar.gz

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.23
+Version: 1.4.24
 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.23 → tricc_oo-1.4.24}/pyproject.toml

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

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo/converters/tricc_to_xls_form.py

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

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo/models/tricc.py

@@ -299,7 +299,7 @@ class TriccNodeSelectOption(TriccNodeDisplayModel):
     select: TriccNodeInputModel
     list_name: str
     def get_datatype(self):
-        if isnumeric(self.name):
+        if self.name.isnumeric():
             return 'number'
         else:
             return 'string'
@@ -323,7 +323,7 @@ class TriccNodeSelect(TriccNodeInputModel):
     list_name: str
     def get_datatype(self):
         rtype = set()
-        for k,o in options.items():
+        for k,o in self.options.items():
             rtype.add(o.get_datatype())
         if len(rtype)>1:
             return 'mixed'

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo/serializers/xls_form.py

@@ -21,6 +21,8 @@ from tricc_oo.visitors.tricc import (
     get_applicability_expression,
     get_prev_instance_skip_expression,
     get_process_skip_expression,
+    get_next_version,
+    set_last_version_false,
 )
 
 logger = logging.getLogger("default")

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo/strategies/output/xls_form.py

@@ -26,7 +26,8 @@ from tricc_oo.visitors.tricc import (
     process_reference,
     get_node_expressions,
     TRICC_TRUE_VALUE,
-    TRICC_FALSE_VALUE
+    TRICC_FALSE_VALUE,
+    set_last_version_false
 )
 from tricc_oo.serializers.xls_form import (
     CHOICE_MAP,
@@ -607,14 +608,18 @@ class XLSFormStrategy(BaseOutPutStrategy):
     # function update the calcualte in the XLSFORM format
     # @param left part
     # @param right part        
-    def generate_xls_form_calculate(self, node, processed_nodes, stashed_nodes, **kwargs):
-        if is_ready_to_process(node, processed_nodes):
+    def generate_xls_form_calculate(self, node, processed_nodes, stashed_nodes, calculates, **kwargs):
+        if is_ready_to_process(node, processed_nodes, strict=False) and process_reference(node, processed_nodes, calculates, replace_reference=False, codesystems= kwargs.get('codesystems', None)):
             if node not in processed_nodes:
                 if kwargs.get('warn', True):          
                     logger.debug("generation of calculate for node {}".format(node.get_name()))
                 if hasattr(node, 'expression') and (node.expression is None) and issubclass(node.__class__,TriccNodeCalculateBase):
                     node.expression = get_node_expressions(node, processed_nodes, process=kwargs.get('process', 'main '))
                     # continue walk
+                if issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase)):
+                    last_version =  set_last_version_false(node, processed_nodes)
+                    if not last_version:
+                        node.last = True
                 return True
         return False
     

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo/visitors/tricc.py

@@ -95,11 +95,11 @@ def get_node_expressions(node, processed_nodes, process=None):
 
 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)
+    #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 and  issubclass(node.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeEnd)) and not isinstance(node, TriccNodeSelectOption))
     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
+        node.version = get_next_version(node.name, processed_nodes, last_version.version + 1)
         last_version.last = False
         node.path_len = max(node.path_len, last_version.path_len + 1)
     return last_version
@@ -116,23 +116,7 @@ def get_version_inheritance(node, last_version, processed_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] 
-                        )
+                    expression = merge_expression(expression, last_version)
                     if node.expression:
                         node.expression = expression
                     elif node.expression_reference:
@@ -141,24 +125,20 @@ def get_version_inheritance(node, last_version, processed_nodes):
                         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("''")]
-                ),
+                #version=get_next_version(node.name, processed_nodes, node.version+2),
+                expression= merge_expression(node, last_version),
+                label= f"merge{node.id}",
                 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)
+            #set_last_version_false(calc, processed_nodes)
             processed_nodes.add(calc)
             if issubclass(node.__class__, TriccNodeInputModel):
                 node.expression = TriccOperation(
@@ -168,6 +148,26 @@ def get_version_inheritance(node, last_version, processed_nodes):
                         last_version
                     ]
                 )
+                
+def merge_expression(expression, last_version):
+    datatype = expression.get_datatype()
+    if datatype == 'boolean':
+        expression = 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] 
+        )
+    return expression
 
 def process_calculate(node,processed_nodes, stashed_nodes, calculates, used_calculates, 
                       warn = False, process=None, **kwargs ):
@@ -479,12 +479,11 @@ def generate_calculates(node,calculates, used_calculates,processed_nodes):
             calc_node.label =  "save select: " +node.get_name()        
         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),
+                #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,
@@ -965,8 +964,8 @@ 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_next_version(name, processed_nodes, version=0, min=100):
+    return max(version, min,*[(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):

{tricc_oo-1.4.23 → tricc_oo-1.4.24}/tricc_oo.egg-info/PKG-INFO

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