tricc-oo 1.5.23__py3-none-any.whl → 1.5.24__py3-none-any.whl

tests/build.py

@@ -3,6 +3,10 @@ from tricc_oo.strategies.output.xlsform_cht_hf import XLSFormCHTHFStrategy
 from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy
 from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy
 from tricc_oo.strategies.output.xls_form import XLSFormStrategy
+from tricc_oo.strategies.output.openmrs_form import OpenMRSStrategy
+from tricc_oo.strategies.output.fhir_form import FHIRStrategy
+from tricc_oo.strategies.output.html_form import HTMLStrategy
+
 from tricc_oo.strategies.input.drawio import DrawioStrategy
 import getopt
 import gettext

tricc_oo/converters/datadictionnary.py

@@ -6,9 +6,13 @@ from fhir.resources.codesystem import (
 
 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."):
@@ -83,7 +87,8 @@ def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attr
             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)

tricc_oo/models/tricc.py

@@ -404,7 +404,7 @@ class TriccNodeSelectYesNo(TriccNodeSelectOne):
     pass
 
 
-class TriccNodeAcceptDiagnostic(TriccNodeSelectOne):
+class TriccNodeAcceptDiagnostic(TriccNodeSelectYesNo):
     severity: Optional[str] = None
     priority: Union[float, int, None] = None
 

tricc_oo/strategies/input/drawio.py

@@ -3,7 +3,7 @@ import os
 
 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,
@@ -47,7 +47,7 @@ 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,

tricc_oo/strategies/output/base_output_strategy.py

@@ -83,6 +83,7 @@ class BaseOutPutStrategy:
     # node function
     @abc.abstractmethod
     def generate_calculate(self, node, **kwargs):
+        # called to generate the calculates on the project
         pass
 
     @abc.abstractmethod
@@ -91,10 +92,14 @@ class BaseOutPutStrategy:
 
     @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
@@ -102,87 +107,116 @@ class BaseOutPutStrategy:
         pass
 
     def tricc_operation_equal(self, ref_expressions):
+        # r[0] = r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_not_equal(self, ref_expressions):
+        # r[0] != r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_not(self, ref_expressions):
+        # !r[0]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_and(self, ref_expressions):
+        # 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):
+        # 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):
+        # (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):
+        # r[0](*r[1:])
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_istrue(self, ref_expressions):
+        # r[0] is true
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_isfalse(self, ref_expressions):
+        # r[0] is false
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_selected(self, ref_expressions):
+        # 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):
+        # 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):
+        # r[0] <= r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_more(self, ref_expressions):
+        # r[0] > r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_less(self, ref_expressions):
+        # r[0] < r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_between(self, ref_expressions):
+        # 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):
+        # 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):
+        # 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):
+        # r[0] contains r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_exists(self, ref_expressions):
+        # r[0] exists
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_has_qualifier(self, ref_expressions):
+        # 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):
+        # 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):
+        # 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):
+        # Patient age in day
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_age_month(self, ref_expressions):
+        # Patient age in Month
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_age_year(self, ref_expressions):
+        # Patient age in Years
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     def tricc_operation_concatenate(self, ref_expressions):
+        # concatenate(*r)
         raise NotImplementedError("This type of opreration  is not supported in this strategy")
 
     # Utils

tricc_oo/strategies/output/fhir_form.py

@@ -0,0 +1,377 @@
+import logging
+import os
+import json
+import datetime
+from tricc_oo.strategies.output.base_output_strategy import BaseOutPutStrategy
+from tricc_oo.models.base import (
+    TriccOperation,
+    TriccStatic, TriccReference
+)
+from tricc_oo.models.tricc import (
+    TriccNodeSelectOption,
+    TriccNodeInputModel,
+    TriccNodeBaseModel
+)
+from tricc_oo.converters.tricc_to_xls_form import get_export_name
+
+logger = logging.getLogger("default")
+
+
+class FHIRStrategy(BaseOutPutStrategy):
+    processes = ["main"]
+    project = None
+    output_path = None
+
+    def __init__(self, project, output_path):
+        super().__init__(project, output_path)
+        self.questionnaires = {}  # segment -> questionnaire
+        self.cql_libraries = {}
+        self.fml_mappings = {}
+
+    def get_tricc_operation_expression(self, operation):
+        # For CQL
+        ref_expressions = []
+        if not hasattr(operation, "reference"):
+            return self.get_tricc_operation_operand(operation)
+        for r in operation.reference:
+            if isinstance(r, list):
+                r_expr = [
+                    (
+                        self.get_tricc_operation_expression(sr)
+                        if isinstance(sr, TriccOperation)
+                        else self.get_tricc_operation_operand(sr)
+                    )
+                    for sr in r
+                ]
+            elif isinstance(r, TriccOperation):
+                r_expr = self.get_tricc_operation_expression(r)
+            else:
+                r_expr = self.get_tricc_operation_operand(r)
+            if isinstance(r_expr, TriccReference):
+                r_expr = self.get_tricc_operation_operand(r_expr)
+            ref_expressions.append(r_expr)
+
+        # build lower level
+        if hasattr(self, f"tricc_operation_{operation.operator}"):
+            callable = getattr(self, f"tricc_operation_{operation.operator}")
+            return callable(ref_expressions)
+        else:
+            raise NotImplementedError(
+                f"This type of operation '{operation.operator}' is not supported in this strategy"
+            )
+
+    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:
+            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")
+        self.process_relevance(self.project.start_pages, pages=self.project.pages)
+
+        logger.info("generate the calculate based on edges")
+        self.process_calculate(self.project.start_pages, pages=self.project.pages)
+
+        logger.info("generate the export format")
+        self.process_export(self.project.start_pages, pages=self.project.pages)
+
+        logger.info("print the export")
+        self.export(self.project.start_pages, version=version)
+
+    def generate_base(self, node, **kwargs):
+        # Generate Questionnaire items per segment
+        segment = getattr(node, 'segment', 'main')
+        if segment not in self.questionnaires:
+            self.questionnaires[segment] = {
+                "resourceType": "Questionnaire",
+                "id": f"questionnaire-{segment}",
+                "url": f"http://example.com/Questionnaire/{segment}",
+                "status": "draft",
+                "item": []
+            }
+        item = {
+            "linkId": get_export_name(node),
+            "text": getattr(node, 'label', ''),
+            "type": self.map_tricc_type_to_fhir(node.tricc_type if hasattr(node, 'tricc_type') else 'text')
+        }
+        if hasattr(node, 'options') and node.options:
+            item["answerOption"] = [{"valueString": opt.name} for opt in node.options]
+        self.questionnaires[segment]["item"].append(item)
+        return True
+
+    def generate_relevance(self, node, **kwargs):
+        # Add enableWhen to Questionnaire item with FHIRPath
+        if hasattr(node, 'expression') and node.expression:
+            segment = getattr(node, 'segment', 'main')
+            if segment in self.questionnaires:
+                for item in self.questionnaires[segment]["item"]:
+                    if item["linkId"] == get_export_name(node):
+                        # Use FHIRPath expression
+                        fhirpath_expr = self.convert_expression_to_fhirpath(node.expression)
+                        item["enableWhen"] = [{
+                            "question": self.get_question_link(node.expression),
+                            "operator": "=",
+                            "answerString": self.get_answer_value(node.expression)
+                        }]
+                        # Alternatively, use expression for complex logic
+                        item["enableWhenExpression"] = {
+                            "language": "text/fhirpath",
+                            "expression": fhirpath_expr
+                        }
+                        break
+        return True
+
+    def generate_calculate(self, node, **kwargs):
+        # Add calculatedExpression to Questionnaire item with FHIRPath
+        if hasattr(node, 'expression') and node.expression:
+            segment = getattr(node, 'segment', 'main')
+            if segment in self.questionnaires:
+                for item in self.questionnaires[segment]["item"]:
+                    if item["linkId"] == get_export_name(node):
+                        fhirpath_expr = self.convert_expression_to_fhirpath(node.expression)
+                        item["calculatedExpression"] = {
+                            "language": "text/fhirpath",
+                            "expression": fhirpath_expr
+                        }
+                        break
+            # Still add to CQL for population if needed
+            if segment not in self.cql_libraries:
+                self.cql_libraries[segment] = f"library {segment}Library version '1.0.0'\n\n"
+            cql_expr = self.convert_expression_to_cql(node.expression)
+            self.cql_libraries[segment] += f"define {get_export_name(node)}: {cql_expr}\n"
+        return True
+
+    def generate_export(self, node, **kwargs):
+        # Generate FML for saving based on content_type
+        content_type = getattr(node, 'content_type', 'Observation')
+        if content_type not in self.fml_mappings:
+            self.fml_mappings[content_type] = f"map \"{content_type}\" {{\n"
+        # Add mapping rules
+        self.fml_mappings[content_type] += f"  {get_export_name(node)} -> {content_type}.{get_export_name(node)}\n"
+        return True
+
+    def export(self, start_pages, version):
+        form_id = start_pages["main"].root.form_id or "fhir_form"
+        base_path = os.path.join(self.output_path, form_id)
+        if not os.path.exists(base_path):
+            os.makedirs(base_path)
+
+        # Export Questionnaires
+        for segment, q in self.questionnaires.items():
+            file_name = f"{segment}.json"
+            path = os.path.join(base_path, file_name)
+            with open(path, 'w') as f:
+                json.dump(q, f, indent=2)
+
+        # Export CQL
+        for segment, cql in self.cql_libraries.items():
+            file_name = f"{segment}.cql"
+            path = os.path.join(base_path, file_name)
+            with open(path, 'w') as f:
+                f.write(cql)
+
+        # Export FML
+        for content_type, fml in self.fml_mappings.items():
+            fml += "}\n"
+            file_name = f"{content_type}.map"
+            path = os.path.join(base_path, file_name)
+            with open(path, 'w') as f:
+                f.write(fml)
+
+        logger.info(f"Exported FHIR resources to {base_path}")
+
+    def map_tricc_type_to_fhir(self, tricc_type):
+        mapping = {
+            'text': 'string',
+            'integer': 'integer',
+            'decimal': 'decimal',
+            'select_one': 'choice',
+            'select_multiple': 'choice',
+            'date': 'date',
+            'time': 'time',
+            'datetime': 'dateTime',
+            'boolean': 'boolean'
+        }
+        return mapping.get(tricc_type, 'string')
+
+    def get_question_link(self, expression):
+        # Simplified, assume first reference
+        if isinstance(expression, TriccOperation) and hasattr(expression, 'reference'):
+            for r in expression.reference:
+                if isinstance(r, TriccReference):
+                    return get_export_name(r.value)
+        return ""
+
+    def get_answer_value(self, expression):
+        # Simplified
+        return "true"
+
+    def get_tricc_operation_operand(self, r):
+        if isinstance(r, TriccOperation):
+            return self.get_tricc_operation_expression(r)
+        elif isinstance(r, TriccReference):
+            return get_export_name(r.value)
+        elif isinstance(r, TriccStatic):
+            if isinstance(r.value, str):
+                return f"'{r.value}'"
+            else:
+                return str(r.value)
+        elif isinstance(r, str):
+            return f"'{r}'"
+        elif isinstance(r, (int, float)):
+            return str(r)
+        elif isinstance(r, TriccNodeSelectOption):
+            return f"'{r.name}'"
+        elif issubclass(r.__class__, TriccNodeInputModel):
+            return get_export_name(r)
+        elif issubclass(r.__class__, TriccNodeBaseModel):
+            return get_export_name(r)
+        else:
+            raise NotImplementedError(f"This type of node {r.__class__} is not supported within an operation")
+
+    def convert_expression_to_cql(self, expression):
+        if isinstance(expression, TriccOperation):
+            return self.get_tricc_operation_expression(expression)
+        else:
+            return self.get_tricc_operation_operand(expression)
+
+    def convert_expression_to_fhirpath(self, expression):
+        # For FHIRPath, similar to CQL but in FHIR context
+        # For questionnaire, references to other questions
+        if isinstance(expression, TriccOperation):
+            return self.get_tricc_operation_expression_fhirpath(expression)
+        else:
+            return self.get_tricc_operation_operand_fhirpath(expression)
+
+    def get_tricc_operation_expression_fhirpath(self, operation):
+        ref_expressions = []
+        if not hasattr(operation, "reference"):
+            return self.get_tricc_operation_operand_fhirpath(operation)
+        for r in operation.reference:
+            if isinstance(r, list):
+                r_expr = [
+                    (
+                        self.get_tricc_operation_expression_fhirpath(sr)
+                        if isinstance(sr, TriccOperation)
+                        else self.get_tricc_operation_operand_fhirpath(sr)
+                    )
+                    for sr in r
+                ]
+            elif isinstance(r, TriccOperation):
+                r_expr = self.get_tricc_operation_expression_fhirpath(r)
+            else:
+                r_expr = self.get_tricc_operation_operand_fhirpath(r)
+            if isinstance(r_expr, TriccReference):
+                r_expr = self.get_tricc_operation_operand_fhirpath(r_expr)
+            ref_expressions.append(r_expr)
+
+        if hasattr(self, f"tricc_operation_fhirpath_{operation.operator}"):
+            callable = getattr(self, f"tricc_operation_fhirpath_{operation.operator}")
+            return callable(ref_expressions)
+        else:
+            # Fallback to CQL operations
+            if hasattr(self, f"tricc_operation_{operation.operator}"):
+                callable = getattr(self, f"tricc_operation_{operation.operator}")
+                return callable(ref_expressions)
+            else:
+                raise NotImplementedError(
+                    f"This type of operation '{operation.operator}' is not supported"
+                )
+
+    def get_tricc_operation_operand_fhirpath(self, r):
+        if isinstance(r, TriccOperation):
+            return self.get_tricc_operation_expression_fhirpath(r)
+        elif isinstance(r, TriccReference):
+            # In FHIRPath, reference to another question's answer
+            return f"%questionnaire.item.where(linkId='{get_export_name(r.value)}').answer.value"
+        elif isinstance(r, TriccStatic):
+            if isinstance(r.value, str):
+                return f"'{r.value}'"
+            else:
+                return str(r.value)
+        elif isinstance(r, str):
+            return f"'{r}'"
+        elif isinstance(r, (int, float)):
+            return str(r)
+        elif isinstance(r, TriccNodeSelectOption):
+            return f"'{r.name}'"
+        elif issubclass(r.__class__, TriccNodeInputModel):
+            return f"%questionnaire.item.where(linkId='{get_export_name(r)}').answer.value"
+        elif issubclass(r.__class__, TriccNodeBaseModel):
+            return f"%questionnaire.item.where(linkId='{get_export_name(r)}').answer.value"
+        else:
+            raise NotImplementedError(f"This type of node {r.__class__} is not supported within an operation")
+
+    # FHIRPath operations, same as CQL for now
+    def tricc_operation_fhirpath_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} = {ref_expressions[1]}"
+
+    def tricc_operation_fhirpath_not_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} != {ref_expressions[1]}"
+
+    def tricc_operation_fhirpath_and(self, ref_expressions):
+        return " and ".join(ref_expressions)
+
+    def tricc_operation_fhirpath_or(self, ref_expressions):
+        return " or ".join(ref_expressions)
+
+    def tricc_operation_fhirpath_not(self, ref_expressions):
+        return f"not {ref_expressions[0]}"
+
+    def tricc_operation_fhirpath_plus(self, ref_expressions):
+        return " + ".join(ref_expressions)
+
+    def tricc_operation_fhirpath_minus(self, ref_expressions):
+        if len(ref_expressions) > 1:
+            return " - ".join(ref_expressions)
+        return f"-{ref_expressions[0]}"
+
+    def tricc_operation_fhirpath_more(self, ref_expressions):
+        return f"{ref_expressions[0]} > {ref_expressions[1]}"
+
+    def tricc_operation_fhirpath_less(self, ref_expressions):
+        return f"{ref_expressions[0]} < {ref_expressions[1]}"
+
+    def tricc_operation_fhirpath_more_or_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} >= {ref_expressions[1]}"
+
+    def tricc_operation_fhirpath_less_or_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} <= {ref_expressions[1]}"
+
+    # Operation methods for CQL
+    def tricc_operation_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} = {ref_expressions[1]}"
+
+    def tricc_operation_not_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} != {ref_expressions[1]}"
+
+    def tricc_operation_and(self, ref_expressions):
+        return " and ".join(ref_expressions)
+
+    def tricc_operation_or(self, ref_expressions):
+        return " or ".join(ref_expressions)
+
+    def tricc_operation_not(self, ref_expressions):
+        return f"not {ref_expressions[0]}"
+
+    def tricc_operation_plus(self, ref_expressions):
+        return " + ".join(ref_expressions)
+
+    def tricc_operation_minus(self, ref_expressions):
+        if len(ref_expressions) > 1:
+            return " - ".join(ref_expressions)
+        return f"-{ref_expressions[0]}"
+
+    def tricc_operation_more(self, ref_expressions):
+        return f"{ref_expressions[0]} > {ref_expressions[1]}"
+
+    def tricc_operation_less(self, ref_expressions):
+        return f"{ref_expressions[0]} < {ref_expressions[1]}"
+
+    def tricc_operation_more_or_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} >= {ref_expressions[1]}"
+
+    def tricc_operation_less_or_equal(self, ref_expressions):
+        return f"{ref_expressions[0]} <= {ref_expressions[1]}"