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

tricc_oo/converters/cql_to_operation.py

@@ -1,9 +1,19 @@
-from antlr4 import *
+from antlr4.error.ErrorListener import ErrorListener
+from antlr4 import CommonTokenStream, InputStream
 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, not_clean, or_join, and_join
+from tricc_oo.models.base import (
+    TriccOperator,
+    TriccOperation,
+    TriccStatic,
+    TriccReference,
+    not_clean,
+    or_join,
+    and_join,
+    string_join,
+)
 import logging
 
 logger = logging.getLogger("default")
@@ -14,15 +24,19 @@ NUMBER = 2
 ANY = 3
 
 FUNCTION_MAP = {
-    'AgeInYears': TriccOperator.AGE_YEAR,
-    'AgeInMonths': TriccOperator.AGE_MONTH,
-    'AgeInDays': TriccOperator.AGE_DAY,
-    'Coalesce': TriccOperator.COALESCE,
-    'Concatenate': TriccOperator.CONCATENATE,
-    'Izscore': TriccOperator.IZSCORE,
-    'Zscore': TriccOperator.ZSCORE,
-    'DrugDosage':  TriccOperator.DRUG_DOSAGE,
-    'HasQualifier': TriccOperator.HAS_QUALIFIER,
+    "AgeInYears": TriccOperator.AGE_YEAR,
+    "AgeInMonths": TriccOperator.AGE_MONTH,
+    "AgeInDays": TriccOperator.AGE_DAY,
+    "Coalesce": TriccOperator.COALESCE,
+    "Concatenate": TriccOperator.CONCATENATE,
+    "Izscore": TriccOperator.IZSCORE,
+    "Zscore": TriccOperator.ZSCORE,
+    "Round": TriccOperator.ROUND,
+    "Integer": TriccOperator.CAST_INTEGER,
+    "DrugDosage": TriccOperator.DRUG_DOSAGE,
+    "HasQualifier": TriccOperator.HAS_QUALIFIER,
+    "DateTimeToDecimal": TriccOperator.DATETIME_TO_DECIMAL,
+    "Count": TriccOperator.COUNT,
 }
 # TODO
 # Min
@@ -30,41 +44,44 @@ FUNCTION_MAP = {
 # Round
 # this need to be done by contribution to DMN
 
+
 class cqlToXlsFormVisitor(cqlVisitor):
     def __init__(self):
         self.xlsform_rows = []
-        self.errors= []
-        
+        self.errors = []
+
     def resolve_scv(self, arg):
-        
-        # TODO 
+
+        # TODO
         # look for the system, if not found fallback on default system
         # look for the code in the system
         # if no code or not found return None
         if arg.startswith('"') and arg.endswith('"'):
             return TriccReference(arg[1:-1])
-        elif arg.lower() in ['true', 'false']:
-            return TriccStatic(arg.lower() == 'true')
-        elif arg != 'runner':
+        elif arg.lower() in ["true", "false"]:
+            return TriccStatic(arg.lower() == "true")
+        elif arg != "runner":
             self.errors.append(f"'{arg}' will be poccessed as reference ")
             return TriccReference(arg)
-        
+
         else:
-            return 'runner'
-        
+            return "runner"
+
     def translate(self, arg, type=ANY):
         return self.resolve_scv(arg) or str(arg)
-    
+
     def visitExpressionDefinition(self, ctx):
         identifier = ctx.identifier().getText()
         expression = self.visit(ctx.expression())
-        self.xlsform_rows.append({
-            'type': 'calculate',
-            'name': clean_name(identifier[1:-1].lower()),
-            'calculation': expression
-        })
+        self.xlsform_rows.append(
+            {
+                "type": "calculate",
+                "name": clean_name(identifier[1:-1].lower()),
+                "calculation": expression,
+            }
+        )
         return expression
-        
+
     def visitIdentifier(self, arg):
         return self.translate(arg.getText(), 1)
 
@@ -77,27 +94,25 @@ class cqlToXlsFormVisitor(cqlVisitor):
                 return aggregate
             else:
                 aggregate = aggregate if isinstance(aggregate, list) else [aggregate]
-                return [
-                    *aggregate,
-                    nextResult
-                ]
+                return [*aggregate, nextResult]
         else:
             return nextResult
 
     def visitExpression(self, ctx):
         return self.visitChildren(ctx)
+
     def visitThisInvocation(self, ctx):
-        return '$this'
-   
+        return "$this"
+
     def visitBooleanLiteral(self, ctx):
-        literal =  ctx.getChild(0).getText()
-        if literal == 'true':
+        literal = ctx.getChild(0).getText()
+        if literal == "true":
             return TriccStatic(True)
-        elif literal == 'false':
+        elif literal == "false":
             return TriccStatic(False)
         else:
             return None
-   
+
     def visitFunctionInvocation(self, ctx, operator=TriccOperator.NATIVE):
         if ctx.getChildCount() == 1:
             return self.visitFunctionInvocation(ctx.getChild(0))
@@ -113,54 +128,45 @@ class cqlToXlsFormVisitor(cqlVisitor):
         args = ctx.paramList()
         if args:
             op.reference += [self.visit(arg) for arg in args.expression() if arg]
-            
 
         return op
-    
+
     def __std_function(self, ctx, operator=TriccOperator.NATIVE):
         args = ctx.expressions
         if args:
             args = [self.visit(arg) for arg in ctx.expression() if arg]
         op = TriccOperation(operator)
-        op.reference = [
-            *args
-        ]
+        op.reference = [*args]
 
     def visitParenthesizedTerm(self, ctx):
         return TriccOperation(TriccOperator.PARENTHESIS, [self.visitChildren(ctx)])
-    
+
     def visitMemberInvocation(self, ctx):
         return self.visitChildren(ctx)
 
     def visitMembershipExpression(self, ctx):
         function_name = ctx.getChild(1).getText()
         return self._get_membership_expression(ctx, function_name)
-        
+
     def _get_membership_expression(self, ctx, function_name):
         left = self.visit(ctx.expression(0))
         right = self.visit(ctx.expression(1))
-        if function_name == 'in':
+        if function_name == "in":
             op = TriccOperation(TriccOperator.SELECTED)
-            op.reference = [
-                right, 
-                left
-            ]
-        elif function_name == 'contains':
+            op.reference = [right, left]
+        elif function_name == "contains":
             op = TriccOperation(TriccOperator.CONTAINS)
-            op.reference = [ 
-                left,
-                right
-            ]
+            op.reference = [left, right]
         return op
-    
+
     def visitNegateMembershipExpression(self, ctx):
         function_name = ctx.getChild(2).getText()
         return not_clean(self._get_membership_expression(ctx, function_name))
-    
+
     def visitInvocationExpressionTerm(self, ctx):
         result = super().visitInvocationExpressionTerm(ctx)
         if isinstance(result, list) and all(isinstance(x, TriccStatic) for x in result):
-            value = '.'.join([x.value for x in result])
+            value = ".".join([x.value for x in result])
             logger.warning(f"guessed reference for '{value}'")
             return TriccReference(value)
         return result
@@ -177,19 +183,19 @@ class cqlToXlsFormVisitor(cqlVisitor):
         expr = self.visit(ctx.expression())
         params = [c.getText() for c in list(ctx.getChildren())[2:]]
         op = TriccOperation(
-            operator = {
-            'true': TriccOperator.ISTRUE,
-            'false': TriccOperator.ISFALSE,
-            'null': TriccOperator.ISNULL
+            operator={
+                "true": TriccOperator.ISTRUE,
+                "false": TriccOperator.ISFALSE,
+                "null": TriccOperator.ISNULL,
             }[params[-1]],
-            reference = [expr]
+            reference=[expr],
         )
-        
-        if params[0] == 'not':
+
+        if params[0] == "not":
             if isinstance(op, TriccStatic) and isinstance(op.value, str):
                 logger.warning(f"not operator on a string {op.value}")
             op = not_clean(op)
-    
+
         return op
 
     def visitExistenceExpression(self, ctx):
@@ -203,18 +209,22 @@ class cqlToXlsFormVisitor(cqlVisitor):
 
     def visitOrExpression(self, ctx):
         return self.__std_operator(TriccOperator.OR, ctx)
-    
+
     def __std_operator(self, operator, ctx):
-        if hasattr(ctx, 'expression'):
+        if hasattr(ctx, "expression"):
             left = self.visit(ctx.expression(0))
             right = self.visit(ctx.expression(1))
-        elif hasattr(ctx, 'expressionTerm'):
+        elif hasattr(ctx, "expressionTerm"):
             left = self.visit(ctx.expressionTerm(0))
             right = self.visit(ctx.expressionTerm(1))
-        if  operator == TriccOperator.AND:
+        if operator == TriccOperator.AND:
             return and_join([left, right])
-        elif  operator == TriccOperator.OR:
-            return or_join([left, right])  
+        elif operator == TriccOperator.OR:
+            return or_join([left, right])
+        elif operator == TriccOperator.CONCATENATE:
+            left = "" if left is None else left
+            right = "" if right is None else right
+            return string_join(left, right)
         else:
             op = TriccOperation(operator, [left, right])
             return op
@@ -244,96 +254,91 @@ class cqlToXlsFormVisitor(cqlVisitor):
         right = self.visit(ctx.expression(1))
         op_text = ctx.getChild(1).getText()
         op_map = {
-            '<': TriccOperator.LESS,
-            '<=': TriccOperator.LESS_OR_EQUAL,
-            '>': TriccOperator.MORE,
-            '>=': TriccOperator.MORE_OR_EQUAL,
-            '=': TriccOperator.EQUAL,
-            '!=': TriccOperator.NOTEQUAL
+            "<": TriccOperator.LESS,
+            "<=": TriccOperator.LESS_OR_EQUAL,
+            ">": TriccOperator.MORE,
+            ">=": TriccOperator.MORE_OR_EQUAL,
+            "=": TriccOperator.EQUAL,
+            "!=": TriccOperator.NOTEQUAL,
         }
         op = TriccOperation(op_map[op_text])
         op.reference = [left, right]
         return op
 
     def visitInvocationExpression(self, ctx):
-        raise NotImplementedError('Invocation not supported')
-    
+        raise NotImplementedError("Invocation not supported")
+
     def visitIndexerExpression(self, ctx):
-        raise NotImplementedError('Indexer not supported')
-    
+        raise NotImplementedError("Indexer not supported")
+
     def visitCastExpression(self, ctx):
         # TODO
-        raise NotImplementedError('Cast not supported')
-    
+        raise NotImplementedError("Cast not supported")
+
     def visitPolarityExpressionTerm(self, ctx):
-        if ctx.getChild(0).getText() == '-':
+        if ctx.getChild(0).getText() == "-":
             return TriccOperation(TriccOperator.MINUS, [self.visit(ctx.getChild(1))])
-    
+
     def visitMultiplicationExpressionTerm(self, ctx):
         op_text = ctx.getChild(1).getText()
         op_map = {
-            '*': TriccOperator.MULTIPLIED,
-            'div': TriccOperator.DIVIDED,
-            '/': TriccOperator.DIVIDED,
-            '%': TriccOperator.MODULO,
-            'mod': TriccOperator.MODULO,
+            "*": TriccOperator.MULTIPLIED,
+            "div": TriccOperator.DIVIDED,
+            "/": TriccOperator.DIVIDED,
+            "%": TriccOperator.MODULO,
+            "mod": TriccOperator.MODULO,
         }
         return self.__std_operator(op_map.get(op_text), ctx)
-    
+
     def visitAdditionExpressionTerm(self, ctx):
         op_text = ctx.getChild(1).getText()
         op_map = {
-            '+': TriccOperator.PLUS,
-            '-': TriccOperator.MINUS,
-            '&': TriccOperator.AND
+            "+": TriccOperator.PLUS,
+            "-": TriccOperator.MINUS,
+            "&": TriccOperator.CONCATENATE,
         }
         return self.__std_operator(op_map.get(op_text), ctx)
 
-    
     def visitTypeExpression(self, ctx):
         to_type = ctx.getChild(2).getText()
         expression = self.visit(ctx.getChild(0))
-        if to_type == 'int' or to_type == 'integer':
+        if to_type == "int" or to_type == "integer":
             return TriccOperation(TriccOperator.CAST_INTEGER, [expression])
-        elif to_type == 'float' or to_type == 'number':
+        elif to_type == "float" or to_type == "number":
             return TriccOperation(TriccOperator.CAST_NUMBER, [expression])
-        elif to_type == 'date':
+        elif to_type == "date":
             return TriccOperation(TriccOperator.CAST_DATE, [expression])
         else:
-            raise NotImplementedError(f'cast {to_type} not supported')
-    
-    def visitUnionExpression(self, ctx):
-        raise NotImplementedError('union not supported')
+            raise NotImplementedError(f"cast {to_type} not supported")
 
-    def visitThisInvocation(self, ctx):
-        # TODO
-        raise NotImplementedError('Implies not supported')
+    def visitUnionExpression(self, ctx):
+        raise NotImplementedError("union not supported")
 
     def visitQuantity(self, ctx):
         # TODO
-        raise NotImplementedError('Indexer not supported')
+        raise NotImplementedError("Indexer not supported")
 
     def visitUnit(self, ctx):
-        raise NotImplementedError('Indexer not supported')
+        raise NotImplementedError("Indexer not supported")
 
     def visistDateTimePrecision(self, ctx):
         # TODO
-        raise NotImplementedError('Indexer not supported')
+        raise NotImplementedError("Indexer not supported")
 
     def visitPluralDateTimePrecision(self, ctx):
         # TODO
-        raise NotImplementedError('Indexer not supported')
+        raise NotImplementedError("Indexer not supported")
 
-    #def visitQualifiedIdentifier(self, ctx):
+    # def visitQualifiedIdentifier(self, ctx):
     #    raise NotImplementedError('qualifiedIdentifier not supported')
 
     def visitTypeSpecifier(self, ctx):
-        raise NotImplementedError('typeSpecifier not supported')
+        raise NotImplementedError("typeSpecifier not supported")
 
     def visitRetrieve(self, ctx):
         # TODO
-        raise NotImplementedError('retrieve not supported')
-    
+        raise NotImplementedError("retrieve not supported")
+
     def visitEqualityExpression(self, ctx):
         return self.visitExpressionComparison(ctx)
 
@@ -358,30 +363,30 @@ class cqlToXlsFormVisitor(cqlVisitor):
         op = TriccOperation(TriccOperator.IF)
         op.reference = [condition, true_value, false_value]
         return op
-    
-    
-from antlr4.error.ErrorListener import ErrorListener
+
 
 class CQLErrorListener(ErrorListener):
     context = None
+
     def __init__(self, context=None):
         super(CQLErrorListener, self).__init__()
         self.errors = []
         self.context = context
 
     def syntaxError(self, recognizer, offendingSymbol, line, column, msg, e):
-        error = f"{self.context} \n" if self.context else ''
+        error = f"{self.context} \n" if self.context else ""
         error += f"Line {line}:{column} - {msg}"
         self.errors.append(error)
 
+
 def transform_cql_to_operation(cql_input, context=None):
     lib_input = f"""
     library runner
-    
+
     define "calc":
         {cql_input.replace('−', '-')}
     """
-    input_stream = InputStream(chr(10).join(lib_input.split('\n')))
+    input_stream = InputStream(chr(10).join(lib_input.split("\n")))
     lexer = cqlLexer(input_stream)
     stream = CommonTokenStream(lexer)
     parser = cqlParser(stream)
@@ -402,14 +407,15 @@ def transform_cql_to_operation(cql_input, context=None):
 
     # If no errors, proceed with visitor
     visitor = cqlToXlsFormVisitor()
-    
+
     visitor.visit(tree)
     if visitor.errors:
         logger.warning(f"while visiting cql: \n{cql_input}")
         for e in visitor.errors:
             logger.warning(e)
-        
-    return visitor.xlsform_rows[0]['calculation']
+
+    return visitor.xlsform_rows[0]["calculation"]
+
 
 def transform_cql_lib_to_operations(cql_input):
     input_stream = InputStream(cql_input)

tricc_oo/converters/datadictionnary.py

@@ -1,22 +1,21 @@
 from fhir.resources.codesystem import (
     CodeSystem,
     CodeSystemConcept,
-    CodeSystemConceptDesignation,
-    CodeSystemConceptProperty
+    CodeSystemConceptProperty,
 )
-from fhir.resources.codeableconcept import CodeableConcept
-from fhir.resources.range import Range
-from fhir.resources.quantity import Quantity
-from fhir.resources.coding import Coding
 
-from fhir.resources.valueset import ValueSet, ValueSetCompose, ValueSetComposeInclude
+from fhir.resources.valueset import ValueSet
 import logging
+import uuid
 
 logger = logging.getLogger("default")
 
+# Namespace for deterministic UUIDs
+UUID_NAMESPACE = uuid.UUID('12345678-1234-5678-9abc-def012345678')
+
 
 def lookup_codesystems_code(codesystems, ref):
-    if ref.startswith('final.'):
+    if ref.startswith("final."):
         concept = lookup_codesystems_code(codesystems, ref[6:])
         if concept:
             return concept
@@ -30,41 +29,39 @@ def add_concept(codesystems, system, code, display, attributes):
     if system and system not in codesystems:
         logger.info(f"New codesystem {system} added to project")
         codesystems[system] = init_codesystem(system, system)
-    
-    
-    
+
     return check_and_add_concept(codesystems[system], code, display, attributes)
-            
 
-                
-    
+
 def init_codesystem(code, name):
     return CodeSystem(
-            id=code.replace('_','-'),
-            url=f"http://example.com/fhir/CodeSystem/{code}",
-            version="1.0.0",
-            name=name,
-            title=name,
-            status="draft",
-            description=f"Code system for {name}",
-            content="complete",
-            concept=[]
-        )
-    
+        id=code.replace("_", "-"),
+        url=f"http://example.com/fhir/CodeSystem/{code}",
+        version="1.0.0",
+        name=name,
+        title=name,
+        status="draft",
+        description=f"Code system for {name}",
+        content="complete",
+        concept=[],
+    )
+
+
 def init_valueset(code, name):
     return ValueSet(
-            id=code,
-            url=f"http://example.com/fhir/ValueSet/{code}",
-            version="1.0.0",
-            name=name,
-            title=name,
-            status="draft",
-            description=f"Valueset for {name}",
-            content="complete",
-            conatains=[]
-        )
-
-def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attributes: dict={}):
+        id=code,
+        url=f"http://example.com/fhir/ValueSet/{code}",
+        version="1.0.0",
+        name=name,
+        title=name,
+        status="draft",
+        description=f"Valueset for {name}",
+        content="complete",
+        conatains=[],
+    )
+
+
+def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attributes: dict = {}):
     """
     Checks if a concept with the given code already exists in the CodeSystem.
     If it exists with a different display, raises an error. Otherwise, adds the concept.
@@ -81,39 +78,33 @@ def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attr
     # Check if the concept already exists
     for concept in code_system.concept or []:
         if concept.code == code:
-            
+
             if concept.display.lower() != display.lower():
                 logger.warning(
-                    f"Code {code} already exists with a different display:\n Concept:{concept.display}\n Current:{display}"
+                    f"""Code {code} already exists with a different display:
+                    Concept:{concept.display}\n Current:{display}"""
                 )
             new_concept = concept
     if not new_concept:
         # Add the new concept if it does not exist
-        new_concept = CodeSystemConcept.construct(code=code, display=display)
+        concept_id = str(uuid.uuid5(UUID_NAMESPACE, display))
+        new_concept = CodeSystemConcept.construct(code=code, display=display, id=concept_id)
         if not hasattr(code_system, "concept"):
             code_system.concept = []
         code_system.concept.append(new_concept)
-    
+
     if attributes and not new_concept.property:
         new_concept.property = []
-    
-    for k,v in attributes.items():          
+
+    for k, v in attributes.items():
         existing_attributes = False
         for p in new_concept.property:
             if p.code == k:
-                #TODO support other type of Codesystem Concept Property Value
+                # TODO support other type of Codesystem Concept Property Value
                 existing_attributes
                 if p.valueString != v:
                     logger.warning(f"conflicting value for property {k}: {p.valueString} != {v}")
         if not existing_attributes:
-            new_concept.property.append(
-                CodeSystemConceptProperty(
-                    code=k,
-                    valueString=v
-                )
-            )
-    
-    return new_concept
-
+            new_concept.property.append(CodeSystemConceptProperty(code=k, valueString=v))
 
-    return value_set
+    return new_concept