tricc-oo 1.4.12__tar.gz → 1.4.14__tar.gz

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.4.12
+Version: 1.4.14
 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.12 → tricc_oo-1.4.14}/pyproject.toml

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

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/converters/cql_to_operation.py

@@ -3,7 +3,7 @@ from tricc_oo.converters.cql.cqlLexer import cqlLexer
 from tricc_oo.converters.cql.cqlParser import cqlParser
 from tricc_oo.converters.cql.cqlVisitor import cqlVisitor
 from tricc_oo.converters.utils import clean_name
-from tricc_oo.models.base import  TriccOperator, TriccOperation, TriccStatic, TriccReference
+from tricc_oo.models.base import  TriccOperator, TriccOperation, TriccStatic, TriccReference, not_clean, or_join, and_join
 import logging
 
 logger = logging.getLogger("default")
@@ -148,7 +148,7 @@ class cqlToXlsFormVisitor(cqlVisitor):
     
     def visitNegateMembershipExpression(self, ctx):
         function_name = ctx.getChild(2).getText()
-        return TriccOperation(TriccOperator.NOT,[self._get_membership_expression(ctx, function_name)])
+        return not_clean(self._get_membership_expression(ctx, function_name))
     
 
     def visitBetweenExpression(self, ctx):
@@ -174,10 +174,7 @@ class cqlToXlsFormVisitor(cqlVisitor):
         if params[0] == 'not':
             if isinstance(op, TriccStatic) and isinstance(op.value, str):
                 logger.warning(f"not operator on a string {op.value}")
-            op = TriccOperation(
-                operator = TriccOperator.NOT,
-                reference = [op]
-            )
+            op = not_clean(op)
     
         return op
 
@@ -200,23 +197,16 @@ class cqlToXlsFormVisitor(cqlVisitor):
         elif hasattr(ctx, 'expressionTerm'):
             left = self.visit(ctx.expressionTerm(0))
             right = self.visit(ctx.expressionTerm(1))
-        if isinstance(left, TriccOperation)   and left.operator ==  operator and operator in (TriccOperator.OR, TriccOperator.AND):
-            left.append(right)
-            return left
-        if isinstance(right, TriccOperation)   and right.operator ==  operator and operator in (TriccOperator.OR, TriccOperator.AND):
-            left.append(left)
-            return right
-        op = TriccOperation(operator)
-        op.reference = [left, right]
-        return op
+        if  operator == TriccOperator.AND:
+            return and_join([left, right])
+        elif  operator == TriccOperator.OR:
+            return or_join([left, right])  
+        else:
+            op = TriccOperation(operator, [left, right])
+            return op
 
     def visitNotExpression(self, ctx):
-        expr = self.visit(ctx.expression())
-        op = TriccOperation(TriccOperator.NOT)
-        if isinstance(expr, TriccStatic) and isinstance(expr.value, str):
-            logger.warning(f"not operator on a string {expr.value}")
-        op.reference = [expr]
-        return op
+        return not_clean(self.visit(ctx.expression()))
 
     def visitIsTrueOrFalseExpression(self, ctx):
         expr = self.visit(ctx.expression())
@@ -245,7 +235,7 @@ class cqlToXlsFormVisitor(cqlVisitor):
             '>': TriccOperator.MORE,
             '>=': TriccOperator.MORE_OR_EQUAL,
             '=': TriccOperator.EQUAL,
-            '!=': TriccOperator.NOT_EQUAL
+            '!=': TriccOperator.NOTEQUAL
         }
         op = TriccOperation(op_map[op_text])
         op.reference = [left, right]

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/converters/tricc_to_xls_form.py

@@ -3,7 +3,7 @@ import re
 
 from tricc_oo.converters.utils import clean_str,clean_name
 from tricc_oo.models import *
-from tricc_oo.visitors.tricc import clean_list_or, negate_term
+from tricc_oo.visitors.tricc import clean_or_list, negate_term
 
 # from babel import _
 

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/converters/utils.py

@@ -4,8 +4,9 @@ import random
 import string
 import hashlib
 from markdownify import markdownify as md
-
-
+import warnings
+from bs4 import MarkupResemblesLocatorWarning
+warnings.filterwarnings("ignore", category=MarkupResemblesLocatorWarning)
 logger = logging.getLogger("default")
 
 
@@ -49,13 +50,16 @@ def get_rand_name(name=None, length=8):
 
 # the soup.text strips off the html formatting also
 def remove_html(string):
-    text = md(
-        string,
-        strip=["img", "table", "a"],
-        strong_em_symbol="*",
-        escape_underscores=False,
-        escape_asterisks=False,
-        bullets=["-", "*"],
-    )
+    
+    if ' ' in string:
+        text = md(
+            string,
+            strip=["img", "table", "a"],
+            strong_em_symbol="*",
+            escape_underscores=False,
+            escape_asterisks=False,
+            bullets=["-", "*"],
+        )
 
-    return text
+        return text
+    return string

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/converters/xml_to_tricc.py

@@ -118,6 +118,7 @@ def create_activity(diagram, media_path, project):
                         activity.root.process == "main" or activity.root.process is None
                     ):
                         project.start_pages["main"] = activity
+                        activity.root.process = 'main'
                     elif activity.root.process is not None:
                         if activity.root.process not in project.start_pages:
                             project.start_pages[activity.root.process] = []
@@ -373,7 +374,7 @@ def create_root_node(diagram):
             label=elm.attrib.get("label"),
             form_id=elm.attrib.get("form_id"),
             relevance=elm.attrib.get("relevance"),
-            process=elm.attrib.get("process") or 'main',
+            process=elm.attrib.get('process', 'main'),
         )
     else:
         elm = get_tricc_type(diagram, "object", TriccNodeType.activity_start)

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/models/base.py

@@ -113,13 +113,25 @@ class TriccBaseModel(BaseModel):
     def get_datatype(self):
         return self.datatype or self.tricc_type
 
+    def to_dict(self):
+        return {key: value for key, value in vars(self).items() if not key.startswith('_')}
+
     def make_instance(self, nb_instance, **kwargs):
         instance = self.copy()
         # change the id to avoid collision of name
         instance.id = generate_id(f"{self.id}{nb_instance}")
         instance.instance = int(nb_instance)
         instance.base_instance = self
-
+        attr_dict = self.to_dict()
+        for attr, value in attr_dict.items():
+            if not attr.startswith('_') and value is not None:
+                try:
+                    if hasattr(value, 'copy'):
+                        setattr(instance, attr, value.copy())
+                    else:
+                        setattr(instance, attr, value)
+                except Exception as e:
+                    logger.warning(f"Warning: Could not copy attribute {attr}: {e}")
         # assign the defualt group
         # if activity is not None and self.group == activity.base_instance:
         #    instance.group = instance
@@ -161,12 +173,6 @@ class TriccEdge(TriccBaseModel):
     target_external_id: triccId = None
     value: Optional[str]  = None
 
-    def make_instance(self, instance_nb, activity=None):
-        instance = super().make_instance(instance_nb, activity=activity)
-        #if issubclass(self.source.__class__, TriccBaseModel):
-        instance.source = self.source if isinstance(self.source, str) else self.source.copy()
-        #if issubclass(self.target.__class__, TriccBaseModel):
-        return instance
 
 
 class TriccGroup(TriccBaseModel):
@@ -319,16 +325,19 @@ class TriccOperator(StrEnum):
     OR = 'or' # or between left and rights
     NATIVE = 'native' #default left is native expression
     ISTRUE = 'istrue' # left is right 
+    ISNOTTRUE = 'isnottrue' 
     ISFALSE = 'isfalse' # left is false
+    ISNOTFALSE = 'isnotfalse' # left is false
     SELECTED = 'selected' # right must be la select and one or several options
     MORE_OR_EQUAL = 'more_or_equal'
     LESS_OR_EQUAL = 'less_or_equal'
     EQUAL = 'equal'
     MORE = 'more'
-    NOT_EQUAL = 'not_equal'
+    NOTEQUAL = 'not_equal'
     BETWEEN = 'between'
     LESS = 'less'
     CONTAINS = 'contains' # ref, txt Does CONTAINS make sense, like Select with wildcard
+    NOTEXISTS = 'notexists'
     EXISTS = 'exists'
     NOT = 'not'
     ISNULL = 'isnull'
@@ -367,13 +376,16 @@ RETURNS_BOOLEAN =[
     TriccOperator.BETWEEN,
     TriccOperator.CONTAINS,
     TriccOperator.EXISTS,
+    TriccOperator.NOTEXISTS,
     TriccOperator.ISFALSE,
+    TriccOperator.ISNOTFALSE,
     TriccOperator.ISNOTNULL,
     TriccOperator.ISTRUE,
+    TriccOperator.ISNOTTRUE,
     TriccOperator.SELECTED,
     TriccOperator.HAS_QUALIFIER,
     TriccOperator.NOT,
-    TriccOperator.NOT_EQUAL,
+    TriccOperator.NOTEQUAL,
     TriccOperator.MORE_OR_EQUAL,
     TriccOperator.LESS_OR_EQUAL,
     TriccOperator.EQUAL,
@@ -405,7 +417,7 @@ OPERATION_LIST = {
     '>=': TriccOperator.MORE_OR_EQUAL,
     '<=': TriccOperator.LESS_OR_EQUAL,
     '==': TriccOperator.EQUAL,
-    '!=': TriccOperator.NOT_EQUAL,
+    '!=': TriccOperator.NOTEQUAL,
     '=': TriccOperator.EQUAL,
     '>': TriccOperator.MORE,
     '<': TriccOperator.LESS
@@ -425,6 +437,9 @@ class TriccOperation(BaseModel):
         str_ref = map(str, self.reference)
         return f"{self.operator}({', '.join(map(str, str_ref))})"
     
+    def __hash__(self):
+        return hash(self.__repr__())
+
     def __repr__(self):
         return "TriccOperation:"+self.__str__()
     
@@ -532,6 +547,186 @@ class TriccOperation(BaseModel):
     def copy(self, keep_node=False):
         return self.__copy__(keep_node)
 
+# function that make multipat  and
+# @param argv list of expression to join with and
+def clean_and_list(argv):
+    for a in list(argv):
+        if isinstance(a, TriccOperation) and a.operator == TriccOperator.AND:
+            argv.remove(a)
+            return clean_and_list([*argv,*a.reference])
+        elif a == TriccStatic(True) or a == True:
+            argv.remove(a)
+        elif a == TriccStatic(False) :
+            return [TriccStatic(False)]
+        
+    internal = list(set(argv))
+    for a in internal:
+        for b in internal[internal.index(a)+1:]:
+            if not_clean(b) == a:
+                return [TriccStatic(False)]
+    return sorted(list(set(argv)), key=str)
+            
+def not_clean(a):
+    new_operator = None
+    if a is None or isinstance(a, str) and a == '':
+        return TriccStatic(False)
+    elif isinstance(a, TriccStatic) and a == TriccStatic(False):
+        return TriccStatic(True)
+    elif isinstance(a, TriccStatic) and a == TriccStatic(True):
+        return TriccStatic(False)
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISTRUE:
+        new_operator = TriccOperator.ISNOTTRUE
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISNOTTRUE:
+        new_operator = TriccOperator.ISTRUE
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISFALSE:
+        new_operator = TriccOperator.ISNOTFALSE
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISNOTFALSE:
+        new_operator = TriccOperator.ISFALSE
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISNULL:
+        new_operator = TriccOperator.ISNOTNULL
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.ISNOTNULL:
+        new_operator = TriccOperator.ISNULL
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.LESS:
+        new_operator = TriccOperator.MORE_OR_EQUAL
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.MORE:
+        new_operator = TriccOperator.LESS_OR_EQUAL
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.LESS_OR_EQUAL:
+        new_operator = TriccOperator.MORE
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.MORE_OR_EQUAL:
+        new_operator = TriccOperator.LESS
+    elif isinstance(a, TriccOperation) and a.operator == TriccOperator.NOT:
+        return a.reference[0]
+    
+    if new_operator:
+        return TriccOperation(
+            new_operator,
+            a.reference
+        )
+    
+    elif not isinstance(a, TriccOperation) and issubclass(a.__class__, object):
+        return TriccOperation(
+                operator=TriccOperator.NOTEXISTS,
+                reference=[a]
+            )
+    else:
+        return TriccOperation(
+            TriccOperator.NOT,
+            [a]
+        )
+        
+    
+      
+# function that generate remove unsure condition
+# @param list_or
+# @param and elm use upstream
+def clean_or_list(list_or, elm_and=None):
+    for a in list(list_or):
+        if isinstance(a, TriccOperation) and a.operator == TriccOperator.OR:
+            list_or.remove(a)
+            return clean_or_list([*list_or,*a.reference])
+        elif a == TriccStatic(False) or a == False or a == 0:
+            list_or.remove(a)
+        elif a == TriccStatic(True) or a == True or a == 1 or (elm_and is not None and not_clean(a) in list_or):
+            return [TriccStatic(True)]
+            # if there is x and not(X) in an OR list them the list is always true
+        elif elm_and is not None and  (not_clean(a) == elm_and or a == elm_and ):
+            list_or.remove(a)
+    internal = list(list_or)    
+    for a in internal:
+        for b in internal[internal.index(a)+1:]:
+            if not_clean(b) == a:
+                return [TriccStatic(True)]
+    if len(list_or) == 0:
+        return []
+
+    return sorted(list(set(list_or)), key=str)
+
+def and_join(argv):
+    argv=clean_and_list(argv)
+    if len(argv) == 0:
+        return ''
+    elif len(argv) == 1:
+        return argv[0]
+    else:
+        return  TriccOperation(
+            TriccOperator.AND,
+            argv
+        )
+
+# function that make a 2 part and
+# @param left part
+# @param right part
+def simple_and_join(left, right):
+    expression = None
+    # no term is considered as True
+    left_issue = left is None or left == ''
+    right_issue = right is None or right == ''
+    left_neg = not_clean(left)
+    right_neg = not_clean(right)
+    if left_issue and right_issue:
+        logger.critical("and with both terms empty")
+    elif left_neg == right or right_neg == left:
+        return TriccStatic(False)
+    elif left_issue:
+        logger.debug('and with empty left term')
+        return  right
+    elif left == '1' or left == 1 or left == TriccStatic(True) or left is True:
+        return  right
+    elif right_issue:
+        logger.debug('and with empty right term')
+        return  left
+    elif right == '1' or right == 1 or right == TriccStatic(True) or right is True:
+        return  left
+    else:
+        return  TriccOperation(
+            TriccOperator.AND,
+            [left, right]
+        )
+
+def or_join(list_or, elm_and=None):
+    cleaned_list  = clean_or_list(list_or, elm_and)
+    if len(cleaned_list) == 1:
+        return cleaned_list[0]
+    elif len(cleaned_list)>1: 
+        return TriccOperation(
+            TriccOperator.OR,
+            cleaned_list
+        )
+    else:
+        logger.error("empty or list")
+    
+    
+    
+# function that make a 2 part NAND
+# @param left part
+# @param right part
+def nand_join(left, right):
+    # no term is considered as True
+    left_issue = left is None or left == ''
+    right_issue = right is None or right == ''
+    left_neg = left == False or left == 0 or left == '0' or left == TriccStatic(False)
+    right_neg = right == False or right == 0 or right == '0' or right == TriccStatic(False)
+    if issubclass(left.__class__, TriccNodeBaseModel):
+        left = get_export_name(left)
+    if issubclass(right.__class__, TriccNodeBaseModel):
+        right = get_export_name(right) 
+    if left_issue and right_issue:
+        logger.critical("and with both terms empty")
+    elif left_issue:
+        logger.debug('and with empty left term')
+        return  negate_term(right)
+    elif left == '1' or left == 1 or left == TriccStatic(True):
+        return  negate_term(right)
+    elif right_issue :
+        logger.debug('and with empty right term')
+        return  TriccStatic(False)
+    elif right == '1' or right == 1 or left_neg or right == TriccStatic(True):
+        return  TriccStatic(False)
+    elif right_neg:
+        return left
+    else:
+        return  and_join([left, negate_term(right)])
+
 
 TriccGroup.update_forward_refs()
 TriccEdge.update_forward_refs()

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/models/calculate.py

@@ -182,7 +182,7 @@ class TriccNodeEnd(TriccNodeDisplayCalculateBase):
     process: str = None
     def __init__(self, **data):
         if data.get('name', None) is None:
-            data['name'] = 'tricc_end_'
+            data['name'] = 'tricc_end_' + data.get('process', '') 
         super().__init__(**data)
         # FOR END
         
@@ -190,9 +190,11 @@ class TriccNodeEnd(TriccNodeDisplayCalculateBase):
 
     def set_name(self):
         if self.name is None:
-            self.name = 'tricc_end'
+            self.name = self.get_reference()
         #self.name = END_NODE_FORMAT.format(self.activity.id)
 
+    def get_reference(self):
+        return 'tricc_end_' + (self.process or '')
 
 class TriccNodeActivityStart(TriccNodeFakeCalculateBase):
     tricc_type: TriccNodeType = TriccNodeType.activity_start

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/models/tricc.py

@@ -32,8 +32,6 @@ class TriccNodeCalculateBase(TriccNodeBaseModel):
             instance.reference = [e.copy() if isinstance(e, (TriccReference, TriccOperation)) else (TriccReference(e.name) if hasattr(e, 'name') else e) for e in self.reference]
         else:
             instance.reference = None
-        if self.expression_reference:
-            instance.expression_reference = self.expression_reference.copy()
         version = self.version + 1
         instance.version = version
         return instance
@@ -237,11 +235,6 @@ class TriccNodeDisplayModel(TriccNodeBaseModel):
     group: Optional[Union[TriccGroup, TriccNodeActivity]] = None
     relevance: Optional[Union[Expression, TriccOperation]] = None
 
-    def make_instance(self, instance_nb, activity=None):
-        instance = super().make_instance(instance_nb, activity=activity)
-        instance.relevance = self.relevance.copy() if self.relevance else None
-       
-        return instance
 
     # to use the enum value of the TriccNodeType
 

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/serializers/xls_form.py

@@ -59,7 +59,7 @@ def start_group(
             relevance_expression
         )
     elif isinstance(relevance_expression, TriccStatic):
-        relevance_expression = str(relevance.value)
+        relevance_expression = str(relevance_expression.value)
 
     # elif is_activity:
     #    relevance_expression = TRICC_CALC_EXPRESSION.format(get_export_name(cur_group.root))

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/strategies/input/base_input_strategy.py

@@ -55,7 +55,8 @@ class BaseInputStrategy:
             root = TriccNodeMainStart(
                 id=generate_id('s-determine-diagnosis'),
                 form_id=root_process.form_id,
-                label=root_process.label
+                label=root_process.label,
+                process='main'
             )
             nodes = {}
             nodes[root.id] = root

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/strategies/input/drawio.py

@@ -11,6 +11,7 @@ from tricc_oo.visitors.tricc import (
     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 *
@@ -22,23 +23,7 @@ logger = logging.getLogger("default")
 
 class DrawioStrategy(BaseInputStrategy):
 
-    processes = [
-        "triage",
-        "registration",
-        "emergency-care",
-        "local-urgent-care",
-        "actue-tertiary-care",
-        "history-and-physical",
-        "diagnostic-testing",
-        "determine-diagnosis",
-        "provide-counseling",
-        "dispense-medications",
-        "monitor-and-follow-up-of-patient",
-        "alerts-reminders-education",
-        "discharge-referral-of-patient",
-        "charge-for-service",
-        "record-and-report",
-    ]
+    processes = PROCESSES
 
     def process_pages(self, start_page, project):
         # create the graph
@@ -57,7 +42,8 @@ class DrawioStrategy(BaseInputStrategy):
             used_calculates=used_calculates,
             calculates=calculates,
             recursive=False,
-            codesystems=project.code_systems
+            codesystems=project.code_systems,
+            process=[start_page.root.process]
         )
 
         logger.info("# check if all edges (arrow) where used")

{tricc_oo-1.4.12 → tricc_oo-1.4.14}/tricc_oo/strategies/output/xls_form.py

@@ -450,6 +450,22 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return f"{ref_expressions[0]}=''"
     def tricc_operation_isnotnull(self, ref_expressions):
         return f"{ref_expressions[0]}!=''"
+    
+    def tricc_operation_isnottrue(self, ref_expressions):
+        if str(BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]).isnumeric():
+            return f"{ref_expressions[0]}<{BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]}"
+        else:
+            return f"{ref_expressions[0]}!={BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]}"
+    def tricc_operation_isnotfalse(self, ref_expressions):
+        if str(BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]).isnumeric():
+            return f"{ref_expressions[0]}>{BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]}"
+        else:
+            return f"{ref_expressions[0]}!={BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]}"
+    def tricc_operation_notexist(self, ref_expressions):
+        return f"{ref_expressions[0]}=''"
+
+    
+    
     def tricc_operation_case(self, ref_expressions):
         ifs = 0
         parts = []
@@ -581,7 +597,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 if kwargs.get('warn', True):          
                     logger.debug("generation of calculate for node {}".format(node.get_name()))
                 if hasattr(node, 'expression') and (node.expression is None) and issubclass(node.__class__,TriccNodeCalculateBase):
-                    node.expression = get_node_expressions(node, processed_nodes)
+                    node.expression = get_node_expressions(node, processed_nodes, process=kwargs.get('process', 'main '))
                     # continue walk
                 return True
         return False