tricc-oo 1.5.13__py3-none-any.whl → 1.6.8__py3-none-any.whl

tricc_oo/strategies/input/drawio.py

@@ -1,20 +1,29 @@
 import logging
 import os
-import json
-from copy import copy
 
 from tricc_oo.converters.xml_to_tricc import create_activity
 from tricc_oo.visitors.tricc import (
-    process_calculate,
+    load_calculate,
     set_prev_next_node,
     replace_node,
     stashed_node_func,
-    TriccProject
 )
 from tricc_oo.visitors.utils import PROCESSES
-from tricc_oo.converters.codesystem_to_ocl import transform_fhir_to_ocl
 
-from tricc_oo.models import *
+from tricc_oo.models import (
+    TriccProject,
+    OrderedSet,
+    TriccNodeActivity,
+    TriccNodeGoTo,
+    TriccNodeLinkOut,
+    TriccNodeMoreInfo,
+    TriccNodeSelect,
+    TriccNodeSelectNotAvailable,
+    TriccRhombusMixIn,
+    get_node_from_list
+
+)
+
 from tricc_oo.strategies.input.base_input_strategy import BaseInputStrategy
 from tricc_oo.parsers.xml import read_drawio
 
@@ -38,12 +47,12 @@ class DrawioStrategy(BaseInputStrategy):
         # add save nodes and merge nodes
         stashed_node_func(
             start_page.root,
-            process_calculate,
+            load_calculate,
             used_calculates=used_calculates,
             calculates=calculates,
             recursive=False,
             codesystems=project.code_systems,
-            process=[start_page.root.process]
+            process=[start_page.root.process],
         )
 
         logger.info("# check if all edges (arrow) where used")
@@ -58,7 +67,6 @@ class DrawioStrategy(BaseInputStrategy):
 
     def execute(self, file_content, media_path):
         project = TriccProject()
-        files = []
         diagrams = []
         # read all project.pages
         logger.info("# Create the activities from diagram project.pages")
@@ -70,7 +78,6 @@ class DrawioStrategy(BaseInputStrategy):
         #     logger.critical(f"no input file found at {in_filepath}")
         #     exit(1)
         # for file in files:
-        images_diagram = []
         for f in file_content:
             file_diagrams = read_drawio(f)
             diagrams += file_diagrams
@@ -81,16 +88,18 @@ class DrawioStrategy(BaseInputStrategy):
                 if id_tab in project.pages:
                     logger.critical(f"{id_tab} diagram (drawio tab) already loaded (Duplicate diagram ID ?)")
                     exit(1)
-                logger.info("Create the activity {0}::{1}".format(
-                    id_tab, name_tab))
-                
-                create_activity(
-                    diagram, media_path, project)
+                logger.info("Create the activity {0}::{1}".format(id_tab, name_tab))
+
+                create_activity(diagram, media_path, project)
                 if len(project.pages) == old_page_len:
                     logger.error(f"diagram {id_tab}::{name_tab} was not loaded properly")
         logger.info("# Create the graph from the start node")
         for k, v in project.code_systems.items():
-            with open(os.path.join(os.path.dirname(media_path),  f"{k}_codesystem.json"), "w", encoding='utf-8') as file:
+            with open(
+                os.path.join(os.path.dirname(media_path), f"{k}_codesystem.json"),
+                "w",
+                encoding="utf-8",
+            ) as file:
                 file.write(v.json(indent=4))
 
         for k, v in project.value_sets.items():
@@ -122,17 +131,18 @@ class DrawioStrategy(BaseInputStrategy):
 
     def linking_nodes(self, node, page, pages, processed_nodes=OrderedSet(), path=[]):
         # get the edges that have that node as source
-
-
         node_edge = list(
-            filter(lambda x: (
-                ( x.source and x.source == node.id) or 
-                (not x.source and x.source_external_id and x.source_external_id == node.external_id) or 
-                x.source == node
-            ), page.edges)
+            filter(
+                lambda x: (
+                    (x.source and x.source == node.id)
+                    or (not x.source and x.source_external_id and x.source_external_id == node.external_id)
+                    or x.source == node
+                ),
+                page.edges,
+            )
         )
         node.activity = page
-                # build current path
+        # build current path
         current_path = path + [node.id]
         # don't stop the walkthroug by default
         for edge in node_edge:
@@ -159,11 +169,9 @@ class DrawioStrategy(BaseInputStrategy):
                                     processed_nodes,
                                     current_path,
                                 )
-                        
+
                     elif isinstance(target_node, TriccNodeGoTo):
-                        next_page = self.walkthrough_goto_node(
-                            target_node, page, pages, processed_nodes, current_path
-                        )
+                        next_page = self.walkthrough_goto_node(target_node, page, pages, processed_nodes, current_path)
                         for n in page.nodes:
                             sn = page.nodes[n]
                             if (
@@ -183,25 +191,24 @@ class DrawioStrategy(BaseInputStrategy):
                         if link_out is not None:
                             target_node = link_out
                     elif isinstance(node, TriccNodeMoreInfo):
-                       
+
                         if target_node.name == node.parent.name:
                             node.parent = target_node
                     if issubclass(target_node.__class__, TriccNodeSelect):
                         for key, option in target_node.options.items():
-                            self.linking_nodes(
-                                option, page, pages, processed_nodes, current_path
-                            )
+                            self.linking_nodes(option, page, pages, processed_nodes, current_path)
                     processed_nodes.add(target_node)
-                    logger.debug("{}::{}: processed ({})".format(
-                        'linking_nodes', target_node.get_name(), len(processed_nodes)))
-                    self.linking_nodes(
-                        target_node, page, pages, processed_nodes, current_path
+                    logger.debug(
+                        "{}::{}: processed ({})".format(
+                            "linking_nodes",
+                            target_node.get_name(),
+                            len(processed_nodes),
+                        )
                     )
+                    self.linking_nodes(target_node, page, pages, processed_nodes, current_path)
                 elif edge.target in current_path:
                     logger.error(
-                        "possible loop detected for node {0} in page {1}; path:".format(
-                            node.get_name(), page.label
-                        )
+                        "possible loop detected for node {0} in page {1}; path:".format(node.get_name(), page.label)
                     )
                     for node_id in current_path:
                         node = get_node_from_list(processed_nodes, node_id)
@@ -212,11 +219,7 @@ class DrawioStrategy(BaseInputStrategy):
                 else:
                     set_prev_next_node(node, target_node)
             else:
-                logger.error(
-                    "target not found {0} for node {1}".format(
-                        edge.target, node.get_name()
-                    )
-                )
+                logger.error("target not found {0} for node {1}".format(edge.target, node.get_name()))
             # page.edges.remove(edge)
 
     def walkthrough_goto_node(self, node, page, pages, processed_nodes, current_path):
@@ -224,23 +227,20 @@ class DrawioStrategy(BaseInputStrategy):
         if node.link in pages:
             next_page = pages[node.link]
             # walk thought the next page
-            max_instance = 1
             if node.instance == 0 or next_page.root.instance == 0:
-                next_page = next_page.make_instance((1000+node.activity.instance) if node.activity.instance>1 else None)
+                next_page = next_page.make_instance(
+                    (1000 + node.activity.instance) if node.activity.instance > 1 else None
+                )
             else:
                 # return existing instance if any
                 next_page = next_page.make_instance(node.instance)
             if next_page.id not in pages:
                 pages[next_page.id] = next_page
             logger.debug(
-                "jumping to page {0}::{1} from {2}".format(
-                    next_page.label, next_page.instance, node.get_name()
-                )
+                "jumping to page {0}::{1} from {2}".format(next_page.label, next_page.instance, node.get_name())
             )
             if next_page not in processed_nodes:
-                self.linking_nodes(
-                    next_page.root, next_page, pages, processed_nodes, current_path
-                )
+                self.linking_nodes(next_page.root, next_page, pages, processed_nodes, current_path)
                 for c in next_page.calculates:
                     if len(c.prev_nodes) == 0:
                         self.linking_nodes(
@@ -250,7 +250,7 @@ class DrawioStrategy(BaseInputStrategy):
                             processed_nodes,
                             current_path,
                         )
-            
+
                 processed_nodes.add(next_page)
 
             replace_node(node, next_page, page)
@@ -259,30 +259,22 @@ class DrawioStrategy(BaseInputStrategy):
             return next_page
         else:
             logger.critical(
-                "node {0} from page {1} doesnot have a valid link: {2}".format(
-                    node.label, page.label, node.link
-                )
+                "node {0} from page {1} doesnot have a valid link: {2}".format(node.label, page.label, node.link)
             )
             exit(1)
 
-    def walkthrough_link_out_node(
-        self, node, page, pages, processed_nodes, current_path
-    ):
+    def walkthrough_link_out_node(self, node, page, pages, processed_nodes, current_path):
         if node.reference is not None:
             link_in_list = []
             link_in_page = None
             for page in pages:
-                link_in_list += list(
-                    filter(lambda x: (x.name == node.reference), page.nodes)
-                )
+                link_in_list += list(filter(lambda x: (x.name == node.reference), page.nodes))
                 # save the first page where a link is found to continue the walktrhough
                 if len(link_in_list) > 0 and link_in_page is None:
                     link_in_page = page
             if len(link_in_list) == 0:
                 logger.warning(
-                    "link in {0} not found for link out {1} in page {2}".format(
-                        node.reference, node.name, page.label
-                    )
+                    "link in {0} not found for link out {1} in page {2}".format(node.reference, node.name, page.label)
                 )
             elif len(link_in_list) > 1:
                 logger.warning(
@@ -300,14 +292,10 @@ class DrawioStrategy(BaseInputStrategy):
                     self.linking_nodes(
                         linked_target_node,
                         link_in_page,
-                        project.pages,
+                        pages,
                         processed_nodes,
                         current_path,
                     )
                 return linked_target_node
         else:
-            logger.warning(
-                "link out {0} in page {1} : reference not found".format(
-                    node.name, page.label
-                )
-            )
+            logger.warning("link out {0} in page {1} : reference not found".format(node.name, page.label))

tricc_oo/strategies/output/base_output_strategy.py

@@ -3,146 +3,232 @@ import logging
 from tricc_oo.visitors.tricc import stashed_node_func
 import datetime
 
-logger = logging.getLogger('default')
+logger = logging.getLogger("default")
 
 
 class BaseOutPutStrategy:
-    processes = ['main']
+    processes = ["main"]
     project = None
     output_path = None
-    # list of supported processes for the strategy, 
+    # list of supported processes for the strategy,
     # the order of the list will be apply
-    
+
     def __init__(self, project, output_path):
         self.output_path = output_path
         self.project = project
-    
+
     def get_tricc_operation_expression(self, operation):
-        raise NotImplemented("get_tricc_operation_expression not implemented")
-    
+        raise NotImplementedError("get_tricc_operation_expression not implemented")
+
     def execute(self):
-        
+
         version = datetime.datetime.now().strftime("%Y%m%d%H%M")
         logger.info(f"build version: {version}")
-        if 'main' in self.project.start_pages:
+        if "main" in self.project.start_pages:
             self.process_base(self.project.start_pages, pages=self.project.pages, version=version)
         else:
             logger.critical("Main process required")
 
-
         logger.info("generate the relevance based on edges")
 
-        
-        
         # create relevance Expression
 
         # create calculate Expression
         self.process_calculate(self.project.start_pages, pages=self.project.pages)
         logger.info("generate the export format")
-         # create calculate Expression
+        # create calculate Expression
         self.process_export(self.project.start_pages, pages=self.project.pages)
-             
+
         logger.info("print the export")
-        
+
         self.export(self.project.start_pages, version=version)
-    
-    ### walking function
+
+        logger.info("validate the output")
+        self.validate()
+
+    # walking function
     def process_base(self, start_pages, **kwargs):
         # for each node, check if condition is required issubclass(TriccNodeDisplayModel)
         # process name
-        stashed_node_func(start_pages[self.processes[0]].root, self.generate_base, **{**self.get_kwargs(),**kwargs} )
-        self.do_clean( **{**self.get_kwargs(),**kwargs})
-        
+        stashed_node_func(
+            start_pages[self.processes[0]].root,
+            self.generate_base,
+            **{**self.get_kwargs(), **kwargs},
+        )
+        self.do_clean(**{**self.get_kwargs(), **kwargs})
+
     def process_relevance(self, start_pages, **kwargs):
-        
-        stashed_node_func(start_pages[self.processes[0]].root, self.generate_relevance, **{**self.get_kwargs(),**kwargs} )
-        self.do_clean( **{**self.get_kwargs(),**kwargs})
-        
+
+        stashed_node_func(
+            start_pages[self.processes[0]].root,
+            self.generate_relevance,
+            **{**self.get_kwargs(), **kwargs},
+        )
+        self.do_clean(**{**self.get_kwargs(), **kwargs})
+
     def process_calculate(self, start_pages, **kwargs):
         # call the strategy specific code
-        stashed_node_func(start_pages[self.processes[0]].root, self.generate_calculate, **{**self.get_kwargs(),**kwargs} )
-        self.do_clean(**{**self.get_kwargs(),**kwargs})
-        
+        stashed_node_func(
+            start_pages[self.processes[0]].root,
+            self.generate_calculate,
+            **{**self.get_kwargs(), **kwargs},
+        )
+        self.do_clean(**{**self.get_kwargs(), **kwargs})
+
     def process_export(self, start_pages, **kwargs):
-        stashed_node_func(start_pages[self.processes[0]].root, self.generate_export, **{**self.get_kwargs(),**kwargs} )
-        self.do_clean(**{**self.get_kwargs(),**kwargs})
-        
- 
+        stashed_node_func(
+            start_pages[self.processes[0]].root,
+            self.generate_export,
+            **{**self.get_kwargs(), **kwargs},
+        )
+        self.do_clean(**{**self.get_kwargs(), **kwargs})
+
     # node function
     @abc.abstractmethod
-    def generate_calculate(self, node, **kwargs ):
-        pass 
+    def generate_calculate(self, node, **kwargs):
+        # called to generate the calculates on the project
+        pass
+
     @abc.abstractmethod
     def generate_base(self, node, **kwargs):
-        pass 
+        pass
 
-    
     @abc.abstractmethod
     def generate_relevance(self, node, **kwargs):
+        # called to generate the references on the project
+
         pass
-    
-        
+
     @abc.abstractmethod
     def generate_export(self, node, **kwargs):
+        # called to the project export
+
         pass
 
     @abc.abstractmethod
     def export(self, **kwargs):
         pass
+
+    @abc.abstractmethod
+    def validate(self):
+        pass
+
     def tricc_operation_equal(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] = r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_not_equal(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] != r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_not(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # !r[0]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_and(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] and r[1] ... and r[n]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_or(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] or r[1] ... or r[n]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_or_and(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # (r[0] or r[1] ... or r[n-1]) and r[n]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_native(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0](*r[1:])
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_istrue(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] is true
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_isfalse(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] is false
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_selected(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # for choice question (single or multiple) it returns true if the second reference is selected
+        # r[1] in r[0]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_more_or_equal(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] >= r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_less_or_equal(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] <= r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_more(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] > r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_less(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] < r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_between(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] between r[1] and r[2]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_case(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # case r[0] when r[1][0] then r[1][1] ...  when r[n-1][0] then r[n-1][1] else (r[n] or None)
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_if(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # if r[0][0] then r[0][1] ... elif r[n-1][0] then r[n-1][1] else (r[n] or None)
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_contains(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] contains r[1]
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_exists(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] exists
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_has_qualifier(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # r[0] is a class and has r[1] qualifier
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_zscore(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # FIXME zscore((gender=r[0], Xfy=r[1], xfY=r[2])
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
+    def tricc_operation_datetime_to_decimal(self, ref_expressions):
+        # cast r[0] in decimal
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
+    def tricc_operation_round(self, ref_expressions):
+        # round(r[0], r[1])
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_izscore(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # FIXME izscore(gender=r[0], Z=r[1], xfY=r[2])
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_age_day(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # Patient age in day
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_age_month(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # Patient age in Month
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_age_year(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
+        # Patient age in Years
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
     def tricc_operation_concatenate(self, ref_expressions):
-        raise NotImplementedError(f"This type of opreration  is not supported in this strategy")
-## Utils
+        # concatenate(*r)
+        raise NotImplementedError("This type of opreration  is not supported in this strategy")
+
+    # Utils
     def do_clean(self, **kwargs):
         pass
+
     def get_kwargs(self):
-        return {} 
+        return {}