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

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

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

{tricc_oo-1.4.19 → tricc_oo-1.4.21}/pyproject.toml

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

{tricc_oo-1.4.19 → tricc_oo-1.4.21}/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.19 → tricc_oo-1.4.21}/tricc_oo/converters/tricc_to_xls_form.py

@@ -35,12 +35,12 @@ def get_export_name(node, replace_dots=True):
         node.gen_name()
         if isinstance(node, TriccNodeSelectOption):
                 node.export_name = node.name
-        elif isinstance(node,  TriccNodeActivityStart):
-            node.export_name =  clean_name(node.name +  INSTANCE_SEPARATOR + str(node.instance), replace_dots=replace_dots)
-        elif isinstance(node, TriccNodeInput):
-            node.export_name = clean_name('load.' +node.name, replace_dots=replace_dots)
         elif node.last == False:
             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 isinstance(node, TriccNodeInput):
+            node.export_name = clean_name('load.' +node.name, replace_dots=replace_dots)
         else:
             node.export_name = clean_name(node.name, replace_dots=replace_dots)
             

{tricc_oo-1.4.19 → tricc_oo-1.4.21}/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]        
         
 
 

tricc_oo-1.4.19/tricc_oo/strategies/output/xlsform_cht_hf.py → tricc_oo-1.4.21/tricc_oo/strategies/output/xlsform_cht.py

@@ -2,19 +2,35 @@ import datetime
 import logging
 import os
 import shutil
-
+import re
 import pandas as pd
 
 from tricc_oo.models.lang import SingletonLangClass
-from tricc_oo.serializers.xls_form import SURVEY_MAP,get_input_line, get_input_calc_line
-from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy
-from tricc_oo.visitors.xform_pd import make_breakpoints, get_tasksstrings
+from tricc_oo.models.calculate import TriccNodeEnd
+from tricc_oo.serializers.xls_form import SURVEY_MAP, get_input_line
+from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy
+from tricc_oo.converters.tricc_to_xls_form import get_export_name
+from tricc_oo.converters.utils import clean_name, remove_html
+from tricc_oo.visitors.xform_pd import make_breakpoints, get_task_js
 
 langs = SingletonLangClass()
 logger = logging.getLogger("default")
 
-class XLSFormCHTHFStrategy(XLSFormCHTStrategy):
+class XLSFormCHTStrategy(XLSFormCDSSStrategy):
+    
+    
+    def process_export(self, start_pages,  **kwargs):
+        diags = []
+        self.activity_export(start_pages[self.processes[0]], **kwargs)
+        #self.add_tab_breaks_choice()
+        cht_header = pd.DataFrame(columns=SURVEY_MAP.keys())
+        cht_input_df = self.get_cht_input( start_pages,  **kwargs)
+        self.df_survey= self.df_survey[~self.df_survey['name'].isin(cht_input_df['name'])]
+        self.df_survey.reset_index(drop=True, inplace=True)
 
+        
+        self.df_survey = pd.concat([cht_input_df, self.df_survey ,self.get_cht_summary() ], ignore_index=True)
+ 
     def get_cht_input(self, start_pages, **kwargs):
         empty = langs.get_trads('', force_dict =True)
         df_input = pd.DataFrame(columns=SURVEY_MAP.keys())
@@ -120,6 +136,7 @@ class XLSFormCHTHFStrategy(XLSFormCHTStrategy):
             *list(empty.values())
             ,'', '', '', '' ,''
         ]
+        self.get_contact_inputs(df_input)
         inputs = self.export_inputs( start_pages[self.processes[0]],  **kwargs)
         for input in inputs:
             df_input.loc[len(df_input)] = get_input_line(input)
@@ -308,27 +325,158 @@ class XLSFormCHTHFStrategy(XLSFormCHTStrategy):
 
         
         
+        return df_input
+        
+    def get_contact_inputs(self, df_input): 
+        empty = langs.get_trads('', force_dict =True)
+
+        df_input.loc[len(df_input)] = [ 
+            'calculate', 'patient_sex',
+            *list(langs.get_trads('Sex', force_dict = True).values()),
+            *list(empty.values()),
+            *list(empty.values()),
+            '',  'hidden',  '',
+            *list(empty.values()),
+            '', '','',
+            *list(empty.values())
+            ,'', '../inputs/contact/sex', '', '' ,''
+        ]  
+        df_input.loc[len(df_input)] = [ 
+            'calculate', 'patient_dob',
+            *list(langs.get_trads('Date of birth', force_dict = True).values()),
+            *list(empty.values()),
+            *list(empty.values()),
+            '',  'hidden',  '',
+            *list(empty.values()),
+            '', '','',
+            *list(empty.values())
+            ,'', 'date(../inputs/contact/date_of_birth)', '', '' ,''
+        ]  
+        
         return df_input
         
     def get_cht_summary(self):
         
         df_summary = pd.DataFrame(columns=SURVEY_MAP.keys())
          #[ #type, '',#name ''#label, '',#hint '',#help '',#default '',#'appearance',  '',#'constraint',  '',#'constraint_message' '',#'relevance' '',#'disabled' '',#'required' '',#'required message' '',#'read only' '',#'expression' '',#'repeat_count' ''#'image' ],
-        #df_summary.loc[len(df_summary)] = [  'begin_group', 'group_summary' , 'Summary',                                  '', '', '',  'field-list summary',  '', '', '', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [  'note',        'r_patient_info', '**${patient_name}** ID: ${patient_id}',  '', '', '',  '',                    '', '', '', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [  'note',        'r_followup', 'Follow Up <i class=“fa fa-flag”></i>', '', '', '',  '',  '', '','', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [  'note',        'r_followup_note' ,'FOLLOWUP instruction', '', '', '',  '',  '', '', '','', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [  'end_group', '' ,'', '', '', '',  '',  '', '', '', '', '', '', '', '','', '' ]
+        #df_summary.loc[len(df_summary)] = [ 'begin group', 'group_summary' , 'Summary',                                  '', '', '',  'field-list summary',  '', '', '', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [ 'note',        'r_patient_info', '**${patient_name}** ID: ${patient_id}',  '', '', '',  '',                    '', '', '', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [ 'note',        'r_followup', 'Follow Up <i class=“fa fa-flag”></i>', '', '', '',  '',  '', '','', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [ 'note',        'r_followup_note' ,'FOLLOWUP instruction', '', '', '',  '',  '', '', '','', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [ 'end group', '' ,'', '', '', '',  '',  '', '', '', '', '', '', '', '','', '' ]
         return df_summary
     
-    def tricc_operation_age_day(self, exps):
-        raise NotImplemented("AgeInDays Not compatible with this strategy")
-    
-    def tricc_operation_age_year(self, exps):
-        raise NotImplemented("AgeInYears Not compatible with this strategy")
-    
-    def tricc_operation_age_month(self, exps):
-        raise NotImplemented("AgeInMonths Not compatible with this strategy")
+    def export(self, start_pages, version, **kwargs):
+        form_id = None
+        if start_pages[self.processes[0]].root.form_id is not None:
+            form_id= str(start_pages[self.processes[0]].root.form_id )
+        else:
+            logger.critical("form id required in the first start node")
+            exit(1)
+        title = remove_html(start_pages[self.processes[0]].root.label)
+        file_name = form_id + ".xlsx"
+        # make a 'settings' tab
+        now = datetime.datetime.now()
+        version=now.strftime('%Y%m%d%H%M')
+        indx=[[1]]
+        # CHT FORCE file name to be equal to id
+        
+        newfilename = form_id + ".xlsx"
+        newpath = os.path.join(self.output_path, newfilename)
+        media_path = os.path.join(self.output_path, form_id + "-media")
+
+        settings={'form_title':title,'form_id':form_id,'version':version,'default_language':'English (en)','style':'pages'}
+        df_settings=pd.DataFrame(settings,index=indx)
+        df_settings.head()
+        if len(self.df_survey[self.df_survey['name'] == 'version'] ):
+            self.df_survey.loc[ self.df_survey['name'] == 'version', 'label'] = f"v{version}"
+        #create a Pandas Excel writer using XlsxWriter as the engine
+        writer = pd.ExcelWriter(newpath, engine='xlsxwriter')
+        self.df_survey.to_excel(writer, sheet_name='survey',index=False)
+        self.df_choice.to_excel(writer, sheet_name='choices',index=False)
+        df_settings.to_excel(writer, sheet_name='settings',index=False)
+        writer.close()
+        # pause
+        ends = []
+        for p in self.project.pages.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:
+            ends_prev = []
+            for e in ends:
+                
+                latest = None
+                for p in e.prev_nodes:
+                    if not latest or latest.path_len < p.path_len:
+                        latest = p
+                if hasattr(latest, 'select'):
+                    latest = latest.select 
+                ends_prev.append(
+                    (int(self.df_survey[self.df_survey.name == latest.export_name].index.values[0]), e,)
+                )
+            forms = [form_id]
+            for i, e in ends_prev:
+                new_form_id = f"{form_id}_{clean_name(e.name)}"
+                newfilename = f"{new_form_id}.xlsx"
+                newpath = os.path.join(self.output_path, newfilename)
+                settings={'form_title':title,'form_id':f"{new_form_id}",'version':version,'default_language':'English (en)','style':'pages'}
+                df_settings=pd.DataFrame(settings,index=indx)
+                df_settings.head()
+                task_df, hidden_names = make_breakpoints(self.df_survey, i, e.name, replace_dots=True)
+                # deactivate the end node
+                task_df.loc[task_df['name'] == get_export_name(e), 'calculation'] = 0
+                #print fileds
+                writer = pd.ExcelWriter(newpath, engine='xlsxwriter')
+                task_df.to_excel(writer, sheet_name='survey',index=False)
+                self.df_choice.to_excel(writer, sheet_name='choices',index=False)
+                df_settings.to_excel(writer, sheet_name='settings',index=False)
+                writer.close()
+                newfilename = f"{new_form_id}.js"
+                newpath = os.path.join(self.output_path, newfilename)
+                with open(newpath, 'w') as f:
+                    f.write(
+                        get_task_js(
+                            new_form_id,
+                            e.name,
+                            f"continue {title}",
+                            forms,
+                            hidden_names,
+                            self.df_survey,
+                            repalce_dots=False,
+                            task_title=e.hint
+                        )
+                    )
+                    f.close()
+                forms.append(new_form_id)
+                
+            
+            
+        media_path_tmp = os.path.join(self.output_path, 'media-tmp')
+        if (os.path.isdir(media_path_tmp)):
+            if os.path.isdir(media_path): # check if it exists, because if it does, error will be raised 
+                shutil.rmtree(media_path)
+                # (later change to make folder complaint to CHT)
+            os.mkdir(media_path)
+            
+            file_names = os.listdir(media_path_tmp)
+            for file_name in file_names:
+                shutil.move(os.path.join(media_path_tmp, file_name), media_path)
+            shutil.rmtree(media_path_tmp)
 
+    def tricc_operation_zscore(self, ref_expressions):
+        y, ll, m, s = self.get_zscore_params(ref_expressions)
+        #  return ((Math.pow((y / m), l) - 1) / (s * l));
+        return f"cht:extension-lib('{ref_expressions[0][1:-1]}.js',{self.clean_coalesce(ref_expressions[1])} ,{self.clean_coalesce(ref_expressions[2])} ,{self.clean_coalesce(ref_expressions[3])})"
+   
+    
+    def tricc_operation_izscore(self, ref_expressions):
+        z, ll, m, s = self.get_zscore_params(ref_expressions)
+        #  return  (m * (z*s*l-1)^(1/l));
+        return f"cht:extension-lib('{ref_expressions[0][1:-1]}.js',{self.clean_coalesce(ref_expressions[1])} ,{self.clean_coalesce(ref_expressions[2])} ,{self.clean_coalesce(ref_expressions[3])}, true)"
     
-    
+    def tricc_operation_drug_dosage(self, ref_expressions):
+        # drug name
+        # age
+        #weight
+        return f"cht:extension-lib('drugs.js',{','.join(map(self.clean_coalesce, ref_expressions))})"

tricc_oo-1.4.21/tricc_oo/strategies/output/xlsform_cht_hf.py

@@ -0,0 +1,43 @@
+import datetime
+import logging
+import os
+import shutil
+
+import pandas as pd
+
+from tricc_oo.models.lang import SingletonLangClass
+from tricc_oo.serializers.xls_form import SURVEY_MAP,get_input_line, get_input_calc_line
+from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy
+from tricc_oo.visitors.xform_pd import make_breakpoints, get_tasksstrings
+
+langs = SingletonLangClass()
+logger = logging.getLogger("default")
+
+class XLSFormCHTHFStrategy(XLSFormCHTStrategy):
+
+   
+    def get_contact_inputs(df_inputs):
+       return None
+        
+    def get_cht_summary(self):
+        
+        df_summary = pd.DataFrame(columns=SURVEY_MAP.keys())
+         #[ #type, '',#name ''#label, '',#hint '',#help '',#default '',#'appearance',  '',#'constraint',  '',#'constraint_message' '',#'relevance' '',#'disabled' '',#'required' '',#'required message' '',#'read only' '',#'expression' '',#'repeat_count' ''#'image' ],
+        #df_summary.loc[len(df_summary)] = [  'begin_group', 'group_summary' , 'Summary',                                  '', '', '',  'field-list summary',  '', '', '', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [  'note',        'r_patient_info', '**${patient_name}** ID: ${patient_id}',  '', '', '',  '',                    '', '', '', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [  'note',        'r_followup', 'Follow Up <i class=“fa fa-flag”></i>', '', '', '',  '',  '', '','', '', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [  'note',        'r_followup_note' ,'FOLLOWUP instruction', '', '', '',  '',  '', '', '','', '', '', '', '', '', '' ]
+        #df_summary.loc[len(df_summary)] = [  'end_group', '' ,'', '', '', '',  '',  '', '', '', '', '', '', '', '','', '' ]
+        return df_summary
+    
+    def tricc_operation_age_day(self, exps):
+        raise NotImplemented("AgeInDays Not compatible with this strategy")
+    
+    def tricc_operation_age_year(self, exps):
+        raise NotImplemented("AgeInYears Not compatible with this strategy")
+    
+    def tricc_operation_age_month(self, exps):
+        raise NotImplemented("AgeInMonths Not compatible with this strategy")
+
+    
+    

{tricc_oo-1.4.19 → tricc_oo-1.4.21}/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)
-            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)
-                # 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 =  set_last_version_false(node, processed_nodes)
+            if 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]
@@ -948,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(
@@ -1207,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)
@@ -1222,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
             
@@ -1238,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
 
 

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

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

tricc_oo-1.4.19/tricc_oo/strategies/output/xlsform_cht.py

@@ -1,200 +0,0 @@
-import datetime
-import logging
-import os
-import shutil
-import re
-import pandas as pd
-
-from tricc_oo.models.lang import SingletonLangClass
-from tricc_oo.models.calculate import TriccNodeEnd
-from tricc_oo.serializers.xls_form import SURVEY_MAP, get_input_line
-from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy
-from tricc_oo.converters.tricc_to_xls_form import get_export_name
-from tricc_oo.converters.utils import clean_name, remove_html
-from tricc_oo.visitors.xform_pd import make_breakpoints, get_task_js
-
-langs = SingletonLangClass()
-logger = logging.getLogger("default")
-
-class XLSFormCHTStrategy(XLSFormCDSSStrategy):
-    
-    
-    def process_export(self, start_pages,  **kwargs):
-        diags = []
-        self.activity_export(start_pages[self.processes[0]], **kwargs)
-        #self.add_tab_breaks_choice()
-        cht_header = pd.DataFrame(columns=SURVEY_MAP.keys())
-        cht_input_df = self.get_cht_input( start_pages,  **kwargs)
-        self.df_survey= self.df_survey[~self.df_survey['name'].isin(cht_input_df['name'])]
-        self.df_survey.reset_index(drop=True, inplace=True)
-
-        
-        self.df_survey = pd.concat([cht_input_df, self.df_survey ,self.get_cht_summary() ], ignore_index=True)
- 
-    def get_cht_input(self, start_pages, **kwargs):
-        df_input = pd.DataFrame(columns=SURVEY_MAP.keys())
-         #[ #type, '',#name ''#label, '',#hint '',#help '',#default '',#'appearance',  '',#'constraint',  '',#'constraint_message' '',#'relevance' '',#'disabled' '',#'required' '',#'required message' '',#'read only' '',#'expression' '',#'repeat_count' ''#'image' ],
-        df_input.loc[len(df_input)] = [ 'begin group', 'inputs' ,*list(langs.get_trads('Inputs', force_dict = True).values()), *list(langs.get_trads('', force_dict = True).values()), *list(langs.get_trads('', force_dict = True).values()), '',  'field-list',  '', *list(langs.get_trads('', force_dict = True).values()), './source = "user"', '','', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'hidden', 'source', *list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'hidden', 'source_id',*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        inputs = self.export_inputs( start_pages[self.processes[0]],  **kwargs)
-        for input in inputs:
-            df_input.loc[len(df_input)] = get_input_line(input)
-        df_input.loc[len(df_input)] = [ 
-            'hidden', 'data_load',
-            *list(langs.get_trads('NO_LABEL', force_dict = True).values()),
-            *list(langs.get_trads('', force_dict = True).values()),
-            *list(langs.get_trads('', force_dict = True).values()),
-            '',  'hidden',  '',
-            *list(langs.get_trads('', force_dict = True).values()),
-            '', '','',
-            *list(langs.get_trads('', force_dict = True).values())
-            ,'', '', '', '' 
-        ]      
-        df_input.loc[len(df_input)] = [ 'hidden', 'task_id' ,*list(langs.get_trads('Task ID', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'begin group	', 'contact' ,*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'db:person', '_id', *list(langs.get_trads('Patient ID', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', 'db-object',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'string', 'patient_id' ,*list(langs.get_trads('Medic ID', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', 'hidden',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'string', 'patient_name',*list(langs.get_trads('Patient Name', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', 'hidden',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'date', 'date_of_birth',*list(langs.get_trads('Date of birth', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', 'hidden',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'string', 'sex',*list(langs.get_trads('Patient Sex', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', 'hidden',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'end group', '' ,*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'end group', '' ,*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()) ,'', '', '', '', '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', '_id' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '',  '../inputs/contact/_id', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'patient_uuid' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '',  '../inputs/contact/patient_id', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_name' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', '../inputs/contact/patient_name', '', '' , '' ]
-
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_age_days' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', 'int((today()-date(${date_of_birth})))', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_age_months' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', 'int(${id.age_day} div 30.4)', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_age_years' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', 'int(${p_age_month} div 12)', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_sex' ,*list(langs.get_trads('label', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', '../inputs/contact/sex', '', '' , '' ]
-        df_input.loc[len(df_input)] = [ 'calculate', 'p_dob',*list(langs.get_trads('Date of birth', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()),*list(langs.get_trads('', force_dict = True).values()), '', '',  '',  *list(langs.get_trads('', force_dict = True).values()), '', '', '', *list(langs.get_trads('', force_dict = True).values()), '', 'date(../inputs/contact/date_of_birth)',  '','' , '' ]
-
-        
-        return df_input
-        
-    def get_cht_summary(self):
-        
-        df_summary = pd.DataFrame(columns=SURVEY_MAP.keys())
-         #[ #type, '',#name ''#label, '',#hint '',#help '',#default '',#'appearance',  '',#'constraint',  '',#'constraint_message' '',#'relevance' '',#'disabled' '',#'required' '',#'required message' '',#'read only' '',#'expression' '',#'repeat_count' ''#'image' ],
-        #df_summary.loc[len(df_summary)] = [ 'begin group', 'group_summary' , 'Summary',                                  '', '', '',  'field-list summary',  '', '', '', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [ 'note',        'r_patient_info', '**${patient_name}** ID: ${patient_id}',  '', '', '',  '',                    '', '', '', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [ 'note',        'r_followup', 'Follow Up <i class=“fa fa-flag”></i>', '', '', '',  '',  '', '','', '', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [ 'note',        'r_followup_note' ,'FOLLOWUP instruction', '', '', '',  '',  '', '', '','', '', '', '', '', '', '' ]
-        #df_summary.loc[len(df_summary)] = [ 'end group', '' ,'', '', '', '',  '',  '', '', '', '', '', '', '', '','', '' ]
-        return df_summary
-    
-    def export(self, start_pages, version, **kwargs):
-        form_id = None
-        if start_pages[self.processes[0]].root.form_id is not None:
-            form_id= str(start_pages[self.processes[0]].root.form_id )
-        else:
-            logger.critical("form id required in the first start node")
-            exit(1)
-        title = remove_html(start_pages[self.processes[0]].root.label)
-        file_name = form_id + ".xlsx"
-        # make a 'settings' tab
-        now = datetime.datetime.now()
-        version=now.strftime('%Y%m%d%H%M')
-        indx=[[1]]
-        # CHT FORCE file name to be equal to id
-        
-        newfilename = form_id + ".xlsx"
-        newpath = os.path.join(self.output_path, newfilename)
-        media_path = os.path.join(self.output_path, form_id + "-media")
-
-        settings={'form_title':title,'form_id':form_id,'version':version,'default_language':'English (en)','style':'pages'}
-        df_settings=pd.DataFrame(settings,index=indx)
-        df_settings.head()
-        if len(self.df_survey[self.df_survey['name'] == 'version'] ):
-            self.df_survey.loc[ self.df_survey['name'] == 'version', 'label'] = f"v{version}"
-        #create a Pandas Excel writer using XlsxWriter as the engine
-        writer = pd.ExcelWriter(newpath, engine='xlsxwriter')
-        self.df_survey.to_excel(writer, sheet_name='survey',index=False)
-        self.df_choice.to_excel(writer, sheet_name='choices',index=False)
-        df_settings.to_excel(writer, sheet_name='settings',index=False)
-        writer.close()
-        # pause
-        ends = []
-        for p in self.project.pages.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:
-            ends_prev = []
-            for e in ends:
-                
-                latest = None
-                for p in e.prev_nodes:
-                    if not latest or latest.path_len < p.path_len:
-                        latest = p
-                if hasattr(latest, 'select'):
-                    latest = latest.select 
-                ends_prev.append(
-                    (int(self.df_survey[self.df_survey.name == latest.export_name].index.values[0]), e,)
-                )
-            forms = [form_id]
-            for i, e in ends_prev:
-                new_form_id = f"{form_id}_{clean_name(e.name)}"
-                newfilename = f"{new_form_id}.xlsx"
-                newpath = os.path.join(self.output_path, newfilename)
-                settings={'form_title':title,'form_id':f"{new_form_id}",'version':version,'default_language':'English (en)','style':'pages'}
-                df_settings=pd.DataFrame(settings,index=indx)
-                df_settings.head()
-                task_df, hidden_names = make_breakpoints(self.df_survey, i, e.name, replace_dots=True)
-                # deactivate the end node
-                task_df.loc[task_df['name'] == get_export_name(e), 'calculation'] = 0
-                #print fileds
-                writer = pd.ExcelWriter(newpath, engine='xlsxwriter')
-                task_df.to_excel(writer, sheet_name='survey',index=False)
-                self.df_choice.to_excel(writer, sheet_name='choices',index=False)
-                df_settings.to_excel(writer, sheet_name='settings',index=False)
-                writer.close()
-                newfilename = f"{new_form_id}.js"
-                newpath = os.path.join(self.output_path, newfilename)
-                with open(newpath, 'w') as f:
-                    f.write(
-                        get_task_js(
-                            new_form_id,
-                            e.name,
-                            f"continue {title}",
-                            forms,
-                            hidden_names,
-                            self.df_survey,
-                            repalce_dots=False,
-                            task_title=e.hint
-                        )
-                    )
-                    f.close()
-                forms.append(new_form_id)
-                
-            
-            
-        media_path_tmp = os.path.join(self.output_path, 'media-tmp')
-        if (os.path.isdir(media_path_tmp)):
-            if os.path.isdir(media_path): # check if it exists, because if it does, error will be raised 
-                shutil.rmtree(media_path)
-                # (later change to make folder complaint to CHT)
-            os.mkdir(media_path)
-            
-            file_names = os.listdir(media_path_tmp)
-            for file_name in file_names:
-                shutil.move(os.path.join(media_path_tmp, file_name), media_path)
-            shutil.rmtree(media_path_tmp)
-
-    def tricc_operation_zscore(self, ref_expressions):
-        y, ll, m, s = self.get_zscore_params(ref_expressions)
-        #  return ((Math.pow((y / m), l) - 1) / (s * l));
-        return f"cht:extension-lib('{ref_expressions[0][1:-1]}.js',{self.clean_coalesce(ref_expressions[1])} ,{self.clean_coalesce(ref_expressions[2])} ,{self.clean_coalesce(ref_expressions[3])})"
-   
-    
-    def tricc_operation_izscore(self, ref_expressions):
-        z, ll, m, s = self.get_zscore_params(ref_expressions)
-        #  return  (m * (z*s*l-1)^(1/l));
-        return f"cht:extension-lib('{ref_expressions[0][1:-1]}.js',{self.clean_coalesce(ref_expressions[1])} ,{self.clean_coalesce(ref_expressions[2])} ,{self.clean_coalesce(ref_expressions[3])}, true)"
-    
-    def tricc_operation_drug_dosage(self, ref_expressions):
-        # drug name
-        # age
-        #weight
-        return f"cht:extension-lib('drugs.js',{','.join(map(self.clean_coalesce, ref_expressions))})"