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

tricc/parsers/xml.py

@@ -1,81 +0,0 @@
-from typing import List
-
-import lxml.etree as etree
-
-
-type_name = 'odk_type'
-
-def read_drawio(filepath):
-
-    root = etree.parse(filepath)
-    # import xml.etree.cElementTree as ET
-    #with open(filepath) as f:
-        #add a fake root so etree can work
-        #it = itertools.chain('<root>', f, '</root>')
-        #etree = ET.fromstringlist(it)
-        #get all the pages
-    diagram_list = root.findall('//diagram')
-  
-    return diagram_list
-
-
-
-def get_container_media(diagram, container_id):
-    # get the edge 
-    return diagram.find(f".//object[@{type_name}='container_hint_media' and @id='{container_id}']")
-    #get the image node 
-
-def get_tricc_type(diagram, node_type, tricc_type):
-    return diagram.find(f'.//{node_type}[@{type_name}="{str(tricc_type)}"]')
-
-
-def get_tricc_type_list(diagram, node_type, tricc_type=None, parent_id = None):
-    tricc_type = str(tricc_type)
-   
-    parent_suffix = f"[@parent='{parent_id}']"  if parent_id is not None else ''
-    if isinstance(tricc_type, list):
-        result = []
-        for type_ in tricc_type:
-            result +=  get_tricc_type_list(diagram, node_type, type_, parent_id)
-        return list(set(result))
-    if isinstance(node_type, list):
-        result = []
-        for type_ in node_type:
-            result +=  get_tricc_type_list(diagram, type_, tricc_type, parent_id)
-        return list(set(result))
-    elif  tricc_type is None:
-        return list(diagram.findall(f'.//{node_type}[@{type_name}]{parent_suffix}'))
-    else:
-        return list(diagram.findall(f'.//{node_type}[@{type_name}="{tricc_type}"]{parent_suffix}'))
-    
-def get_mxcell_parent_list(diagram, select_id, tricc_type =None, attrib = None):
-    #get the mxcels
-    if tricc_type is None:
-        if attrib is not None:
-            return diagram.findall(f".//mxCell[@parent='{select_id}']/..[@{attrib}]")
-        else:
-            return diagram.findall(f".//mxCell[@parent='{select_id}']")
-    elif isinstance(tricc_type, List):
-        result = []
-        for type in tricc_type:
-            result +=  get_mxcell_parent_list(diagram, select_id, type)
-        return result
-    else:
-        return diagram.findall(f".//mxCell[@parent='{select_id}']/..[@{type_name}='{tricc_type}']")
-
-def get_mxcell(diagram, id):
-    return diagram.find(f".//*[@id='{id}']")
-
-def get_edges_list(diagram):
-    #return list(diagram.findall('.//mxCell[@edge][@source][@target]'))
-    # to ensure source and target one can use this xpath above but better trigger a pydantic error if source/target are missing
-    return list(set( diagram.findall('.//mxCell[@edge][@source]') + diagram.findall('.//mxCell[@edge][@target]')))  
-
-
-def get_select_option_image(diagram, select_option_id):
-    # get the edge 
-    edge=diagram.find(f".//mxCell[@edge and @target='{select_option_id}']")
-    #get the image node 
-    if edge is not None and edge.attrib.get('source') is not None:
-        return diagram.find(f".//mxCell[@id='{edge.attrib.get('source')}' and not(@{type_name}) and not(@edge)]")
-    

tricc/serializers/xls_form.py

@@ -1,364 +0,0 @@
-
-
-import logging
-
-from tricc.converters.tricc_to_xls_form import (TRICC_CALC_EXPRESSION,
-                                                negate_term, VERSION_SEPARATOR,INSTANCE_SEPARATOR,  get_export_name)
-from tricc.converters.utils import clean_name, remove_html
-from tricc.models.lang import SingletonLangClass
-from tricc.models.tricc import *
-
-logger = logging.getLogger('default')
-
-langs = SingletonLangClass()
-
-
-def start_group( cur_group, groups, df_survey, df_calculate, relevance = False, **kargs):
-    name = get_export_name(cur_group)
-    
-    if name in groups:
-        groups[name] += 1
-        name = (name + "_" + str(groups[name]))
-        
-    else:
-        groups[name] = 0
-    is_activity = isinstance(cur_group,TriccNodeActivity)
-    relevance = relevance and  cur_group.relevance is not None and cur_group.relevance != '' 
-    group_calc_required = False and relevance and not is_activity and len(relevance)> 100
-    
-    
-    
-    relevance_expression = cur_group.relevance
-    if not relevance:
-        relevance_expression = ''
-    #elif is_activity:
-    #    relevance_expression = TRICC_CALC_EXPRESSION.format(get_export_name(cur_group.root))
-    elif group_calc_required:
-        relevance_expression = TRICC_CALC_EXPRESSION.format("gcalc_" + name)
-        
-## group
-    values = []
-    for column in SURVEY_MAP:
-        if column == 'type':
-            values.append('begin group')
-        elif column == 'name':
-            values.append(name)   
-        elif  column == 'appearance':
-            values.append('field-list')
-        elif column == 'relevance':
-            values.append(relevance_expression)
-        else:
-            values.append(get_xfrom_trad(cur_group,column,SURVEY_MAP))
-    df_survey.loc[len(df_survey)] = values
-
-    ### calc
-    if  group_calc_required and len(df_calculate[df_calculate['name'] == "gcalc_" + name]) == 0:
-        calc_values =[]
-        for column in SURVEY_MAP:
-            if column == 'type':
-                calc_values.append('calculate')
-            elif column == 'name':
-                value =  "gcalc_" + name
-                calc_values.append(value)   
-            elif column == 'calculation':
-                calc_values.append(get_attr_if_exists(cur_group,'relevance',SURVEY_MAP))
-            elif column == 'relevance':
-                calc_values.append('')
-            else:
-                calc_values.append(get_xfrom_trad(cur_group,column,SURVEY_MAP))
-
-        df_calculate.loc[len(df_calculate)] = calc_values
-    
-    
-
-def end_group( cur_group, groups, df_survey, **kargs):
-    
-    values = []
-    for column in SURVEY_MAP:
-        if column == 'type':
-            values.append('end group')
-        elif column == 'relevance':
-             values.append('')
-        elif column in ('name'):
-            value = (get_attr_if_exists(cur_group,column,SURVEY_MAP))
-            
-            if get_export_name(cur_group) in groups:
-                value = (value + "_" + str(groups[get_export_name(cur_group)]))
-            values.append(value)
-        else:
-            values.append(get_xfrom_trad(cur_group,column,SURVEY_MAP))
-    df_survey.loc[len(df_survey)] = values
-
-
-    # waltk thought the node,
-    # if node has group, open the group (and parent group)
-    # check process the next_node with the same group first, then process the other
-    
-    # if node has another group (not current) close the group
-    # if node is an activity close  the group
-    
-    # during tricc object building/ or par of the stategy
-    # static calculte node with same name:
-    # follow same approach as the dynamic
-    # if reference not in used_saves
-    #   , then create calculate node reference_1 # and save is used_saves 'reference' : 1  
-    # else create calculate node reference_(used_saves['reference']+1) # and update used_saves['reference'] += 1
-    # once done, walkthrough again and remame  reference_(used_saves['reference']) to reference and create the other save 
-ODK_TRICC_TYPE_MAP = { 'note':'note'
-    ,'calculate':'calculate'
-    ,'select_multiple':'select_multiple'
-    ,'select_one':'select_one'
-    ,'decimal':'decimal'
-    ,'integer':'integer'
-    ,'text':'text'
-    ,'rhombus':'calculate'
-    ,'goto':''#: start the linked activity within the target activity
-    ,'start':''
-    ,'activity_start':'calculate'
-    ,'link_in':''
-    ,'link_out':''
-    ,'count':'calculate'
-    ,'add':'calculate'
-    ,'container_hint_media':''
-    ,'activity':''
-    ,'select_option':''
-    ,'hint':''
-    ,'help':''
-    ,'exclusive':'calculate'
-    ,'end':'calculate'
-    ,'activity_end':'calculate'
-    ,'edge':''
-    ,'page':''
-    ,'bridge':'calculate'
-    ,'date':'date'
-    }
-
-GROUP_TRICC_TYPE = [TriccNodeType.page,TriccNodeType.activity]
-          
-SURVEY_MAP = {
-    'type':ODK_TRICC_TYPE_MAP, 'name':'name',
-    **langs.get_trads_map('label'), **langs.get_trads_map('hint'),
-    **langs.get_trads_map('help'), 'default':'default', 
-    'appearance':'appearance', 'constraint':'constraint', 
-    **langs.get_trads_map('constraint_message'), 'relevance':'relevance',
-    'disabled':'disabled','required':'required',
-    **langs.get_trads_map('required_message'), 'read only':'read only', 
-    'calculation':'expression','repeat_count':'repeat_count','media::image':'image'
-}
-CHOICE_MAP = {'list_name':'list_name', 'value':'name', **langs.get_trads_map('label') }
-     
-     
-TRAD_MAP = ['label','constraint_message', 'required_message', 'hint', 'help']  
-
-def get_xfrom_trad(node, column, maping, clean_html = False ):
-    arr = column.split('::')
-    column = arr[0]
-    trad =  arr[1] if len(arr)==2 else None
-    value = get_attr_if_exists(node, column, maping)
-    if clean_html and isinstance(value, str):
-        value = remove_html(value)
-    if column in TRAD_MAP:
-        value = langs.get_trads(value, trad=trad)
-
-    return value
-
-    
-
-
-def get_attr_if_exists(node,column, map_array):
-    if column in map_array:
-        mapping = map_array[column]
-        if isinstance(mapping, Dict) and node.tricc_type in map_array[column]:
-            tricc_type =  map_array[column][node.tricc_type]
-            if tricc_type[:6] == "select":
-                return tricc_type + " " + node.list_name
-            else:
-                return tricc_type
-        elif hasattr(node, map_array[column]):
-            value =  getattr(node, map_array[column])
-            if column == 'name':
-                if issubclass(value.__class__, (TriccNodeBaseModel)):
-                    return get_export_name(value)
-                else:
-                    return get_export_name(node)
-            elif value is not None:
-                return str(value) if not isinstance(value,dict) else value
-            else:
-                return ''
-        else:
-            return ''
-    elif hasattr(node, column) and getattr(node, column) is not None:
-        value = getattr(node, column)
-        return str(value) if not isinstance(value,dict) else value
-    else:
-        return ''
-
- 
-def generate_xls_form_export(node, processed_nodes, stashed_nodes, df_survey, df_choice,df_calculate, cur_group, **kargs):
-    # check that all prev nodes were processed
-    if is_ready_to_process(node,processed_nodes):
-        if node not in processed_nodes :
-            if node.group != cur_group and not isinstance(node,TriccNodeSelectOption) : 
-                return False
-            logger.debug("printing node {}".format(node.get_name()))
-            # clean stashed node when processed
-            if node in stashed_nodes:
-                stashed_nodes.remove(node)
-                logger.debug("generate_xls_form_export: unstashing processed node{} ".format(node.get_name()))
-            if issubclass(node.__class__, ( TriccNodeDisplayCalculateBase,TriccNodeDisplayModel)):
-                if isinstance(node, TriccNodeSelectOption):
-                    values = []
-                    for column in CHOICE_MAP:
-                        values.append(get_xfrom_trad(node, column, CHOICE_MAP, True ))
-                    # add only if not existing
-                    if len(df_choice[(df_choice['list_name'] == node.list_name) & (df_choice['value'] == node.name)])  == 0:
-                        df_choice.loc[len(df_choice)] = values
-                elif node.tricc_type in ODK_TRICC_TYPE_MAP and ODK_TRICC_TYPE_MAP[node.tricc_type] is not None:
-                    if ODK_TRICC_TYPE_MAP[node.tricc_type] =='calculate':
-                        values = []
-                        for column in SURVEY_MAP:
-                            if column == 'default' and issubclass(node.__class__, TriccNodeDisplayCalculateBase):
-                                values.append(0)
-                            else:
-                                values.append(get_xfrom_trad(node, column, SURVEY_MAP ))
-                        if len(df_calculate[df_calculate.name == get_export_name(node)])==0:
-                            df_calculate.loc[len(df_calculate)] = values
-                        else:
-                            logger.error("name {} found twice".format(node.name))
-                        
-                    elif  ODK_TRICC_TYPE_MAP[node.tricc_type] !='':
-                        values = []
-                        for column in SURVEY_MAP:
-                            values.append(get_xfrom_trad(node,column,SURVEY_MAP))
-                        df_survey.loc[len(df_survey)] = values
-                    else:
-                        logger.warning("node {} have an unmapped type {}".format(node.get_name(),node.tricc_type))
-                else:
-                    logger.warning("node {} have an unsupported type {}".format(node.get_name(),node.tricc_type))
-            #continue walk °
-            return True
-    return False
-
-
-def get_diagnostic_line(node):
-    label = langs.get_trads(node.label, force_dict =True)
-    empty = langs.get_trads('', force_dict =True)
-    return [
-        'select_one yes_no',
-        "cond_"+get_export_name(node),
-        *list(label.values()) ,
-        *list(empty.values()) ,#hint
-        *list(empty.values()) ,#help
-        '',#default
-        '',#'appearance', clean_name
-        '',#'constraint', 
-        *list(empty.values()) ,#'constraint_message'
-        TRICC_CALC_EXPRESSION.format(get_export_name(node)),#'relevance'
-        '',#'disabled'
-        '1',#'required'
-        *list(empty.values()) ,#'required message'
-        '',#'read only'
-        '',#'expression'
-        '',#'repeat_count'
-        ''#'image'  
-    ]
-
-def get_diagnostic_start_group_line():
-    label = langs.get_trads('List of diagnostics', force_dict =True)
-    empty = langs.get_trads('', force_dict =True)
-    return [
-        'begin group',
-        "l_diag_list25",
-        *list(label.values()) ,
-        *list(empty.values()) ,#hint
-        *list(empty.values()) ,#help
-        '',#default
-        'field-list',#'appearance', 
-        '',#'constraint', 
-        *list(empty.values()) ,#'constraint_message'
-        '',#'relevance'
-        '',#'disabled'
-        '',#'required'
-        *list(empty.values()) ,#'required message'
-        '',#'read only'
-        '',#'expression'
-        '',#'repeat_count'
-        ''#'image'  
-    ]
-    
-def get_diagnostic_add_line(diags, df_choice):
-    for diag in diags:
-        df_choice.loc[len(df_choice)] =  [
-            "tricc_diag_add",
-            get_export_name(diag),
-            *list(langs.get_trads(diag.label, True).values())
-        ]
-    label = langs.get_trads('Add a missing diagnostic', force_dict =True)
-    empty = langs.get_trads('', force_dict =True)
-    return [
-        'select_multiple tricc_diag_add',
-        "new_diag",
-        *list(label.values()) ,
-        *list(empty.values()) ,#hint
-        *list(empty.values()) ,#help
-        '',#default
-        'minimal',#'appearance', 
-        '',#'constraint', 
-        *list(empty.values()) ,#'constraint_message',
-        '',#'relevance'
-        '',#'disabled'
-        '',#'required'
-        *list(empty.values()) ,#'required message'
-        '',#'read only'
-        '',#'expression'
-        '',#'repeat_count'
-        ''#'image'  
-    ]  
-    
-def get_diagnostic_none_line(diags):
-    relevance = ''
-    for diag in diags:
-        relevance += TRICC_CALC_EXPRESSION.format(get_export_name(diag)) + " or "
-    label = langs.get_trads('Aucun diagnostic trouvé par l\'outil mais cela ne veut pas dire que le patient est en bonne santé', force_dict =True)
-    empty = langs.get_trads('', force_dict =True)
-    return [
-        'note',
-        "l_diag_none25",
-        *list(label.values()) ,
-        *list(empty.values()) ,
-        *list(empty.values()) ,
-        '',#default
-        '',#'appearance', 
-        '',#'constraint', 
-        *list(empty.values()) ,
-        negate_term(relevance[:-4]),#'relevance'
-        '',#'disabled'
-        '',#'required'
-        *list(empty.values()) ,
-        '',#'read only'
-        '',#'expression'
-        '',#'repeat_count'
-        ''#'image'  TRICC_NEGATE
-    ]
-    
-def  get_diagnostic_stop_group_line():
-        label = langs.get_trads('', force_dict =True)
-        return [
-        'end group',
-        "l_diag_list25",
-        *list(label.values()) ,
-        *list(label.values()) ,
-        *list(label.values()) ,#help
-        '',#default
-        '',#'appearance', 
-        '',#'constraint', 
-        *list(label.values()) ,
-        '',#'relevance'
-        '',#'disabled'
-        '',#'required'
-        *list(label.values()) ,
-        '',#'read only'
-        '',#'expression'
-        '',#'repeat_count'
-        ''#'image'  
-    ]

tricc/strategies/input/base_input_strategy.py

@@ -1,80 +0,0 @@
-import abc
-
-from tricc.models.tricc import (
-    stashed_node_func,
-    TriccNodeMainStart,
-    TriccNodeActivity,
-    TriccEdge,
-)
-from tricc.converters.utils import generate_id
-from tricc.visitors.tricc import get_activity_wait
-from tricc.models.tricc import set_prev_next_node
-from itertools import chain
-import logging
-
-logger = logging.getLogger("default")
-
-
-class BaseInputStrategy:
-    input_path = None
-
-    processes = ["main"]
-
-    def execute_linked_process(self, start_pages, pages):
-        # create an overall activity only if not specified
-        if "main" not in start_pages:
-            # set the first proess as the first form the list
-            if not self.processes[0] in start_pages:
-                logger.error(
-                    f"MainStart without process or process in (None, main, {self.processes[0]}) mandatory or this strategy {self.__class__.__name__}"
-                )
-            # copie the first root process data to use it on the app level
-            root_process = start_pages[self.processes[0]][0].root
-            root = TriccNodeMainStart(
-                id=generate_id(), form_id=root_process.form_id, label=root_process.label
-            )
-            # first sets of activities don't require wait node
-            root.next_nodes = start_pages[self.processes[0]]
-
-            nodes = {page.id: page for x in start_pages for page in start_pages[x]}
-            nodes[root.id] = root
-            app = TriccNodeActivity(
-                id=generate_id(), name=root_process.name, root=root, nodes=nodes
-            )
-            root.activity = app
-            # loop back to app to avoid None
-            app.activity = app
-            app.group = app
-            # setting the activity/group to main
-            for n in nodes.values():
-                n.activity = app
-                n.group = app
-            # put a wait between group pf activities
-            prev_process = start_pages[self.processes[0]]
-            for p in prev_process:
-                set_prev_next_node(root, p, edge_only=True)
-            for process in self.processes[1:]:
-                if process in start_pages:
-                    wait = get_activity_wait(
-                        [app.root],
-                        prev_process,
-                        start_pages[process],
-                        edge_only=True,
-                        activity=app,
-                    )
-                    app.nodes[wait.id] = wait
-                    prev_process = start_pages[process]
-                    # for p in prev_process:
-                    #    set_prev_next_node(root,p)
-
-            return app
-        else:
-            return start_pages["main"]
-
-    def __init__(self, input_path):
-        self.input_path = input_path
-
-    ### walking function
-    @abc.abstractmethod
-    def execute(in_filepath, media_path):
-        pass