tricc-oo 1.0.2__py3-none-any.whl → 1.4.16__py3-none-any.whl

tests/build.py

@@ -0,0 +1,213 @@
+import getopt
+import gettext
+import logging
+import os
+import sys
+import gc
+import shutil
+from pathlib import Path
+
+# set up logging to file
+from tricc_oo.models.lang import SingletonLangClass
+
+# gettext.bindtextdomain('tricc', './locale/')
+# gettext.textdomain('tricc')
+langs = SingletonLangClass()
+
+# fr =  gettext.translation('tricc', './locales' , languages=['fr'])
+# fr.install()
+# en =  gettext.translation('tricc', './locales' , languages=['en'])
+# en.install()
+
+
+# langs.add_trad('fr', fr)
+# langs.add_trad('en', en)
+
+from tricc_oo.strategies.input.drawio import DrawioStrategy
+
+# from tricc_oo.serializers.medalcreator import execute
+
+from tricc_oo.strategies.output.xls_form import XLSFormStrategy
+from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy
+from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy
+from tricc_oo.strategies.output.xlsform_cht_hf import XLSFormCHTHFStrategy
+from tricc_oo.strategies.output.spice import SpiceStrategy
+
+def setup_logger(
+    logger_name,
+    log_file,
+    level=logging.INFO,
+    formatting="[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s",
+):
+    l = logging.getLogger(logger_name)
+    formatter = logging.Formatter(formatting)
+    file_handler = logging.FileHandler(log_file, mode="w+")
+    file_handler.setFormatter(formatter)
+    stream_handler = logging.StreamHandler()
+    stream_handler.setFormatter(formatter)
+
+    l.setLevel(level)
+    l.addHandler(file_handler)
+
+
+class ColorFormatter(logging.Formatter):
+    # Define ANSI escape codes for colors
+    grey = "\x1b[38;21m"
+    yellow = "\x1b[33;21m"
+    red = "\x1b[31;21m"
+    bold_red = "\x1b[31;1m"
+    reset = "\x1b[0m"
+    format = "%(asctime)s - %(name)s - %(levelname)s - %(message)s (%(filename)s:%(lineno)d)"
+
+    # Map log levels to their respective colors
+    FORMATS = {
+        logging.DEBUG: grey + format + reset,
+        logging.INFO: grey + format + reset,
+        logging.WARNING: yellow + format + reset,
+        logging.ERROR: red + format + reset,
+        logging.CRITICAL: bold_red + format + reset,
+    }
+
+    def format(self, record):
+        # Get the appropriate color format for the log level
+        log_fmt = self.FORMATS.get(record.levelno)
+        formatter = logging.Formatter(log_fmt)
+        return formatter.format(record)
+
+
+logger = logging.getLogger("default")
+
+
+# set up logging to console
+console = logging.StreamHandler()
+console.setLevel(logging.INFO)
+# set a format which is simpler for console use
+console.setFormatter(ColorFormatter())
+# add the handler to the root logger
+logging.getLogger("default").addHandler(console)
+
+LEVELS = {
+    "d": logging.DEBUG,
+    "w": logging.WARNING,
+    "i": logging.INFO,
+}
+
+
+def print_help():
+    print(
+        "-i / --input draw.io filepath (MANDATORY) or directory containing drawio files"
+    )
+    print("-o / --output xls file ")
+    print("-d form_id ")
+    print("-s L4 system/strategy (odk, cht, cc)")
+    print("-h / --help print that menu")
+
+
+if __name__ == "__main__":
+    gc.disable()
+
+    system = "odk"
+    in_filepath = None
+    out_path = None
+    form_id = None
+    debug_level = None
+    trad = False
+    download_dir = None
+    input_strategy = "DrawioStrategy"
+    output_strategy = "XLSFormStrategy"
+    try:
+        opts, args = getopt.getopt(
+            sys.argv[1:], "hti:o:s:I:O:l:d:D:", ["input=", "output=", "help", "trads"]
+        )
+    except getopt.GetoptError:
+        print_help()
+        sys.exit(1)
+    for opt, arg in opts:
+        if opt in ("-h", "--help"):
+            print_help()
+            sys.exit()
+        elif opt in ("-i", "--input"):
+            in_filepath = arg
+        elif opt == "-o":
+            out_path = arg
+        elif opt == "-I":
+            input_strategy = arg
+        elif opt == "-O":
+            output_strategy = arg
+        elif opt == "-d":
+            form_id = arg
+        elif opt == "-l":
+            debug_level = arg
+        elif opt in ("-t", "--trads"):
+            trad = True
+        elif opt == "-D":
+            download_dir = arg
+    if in_filepath is None:
+        print_help()
+        sys.exit(2)
+    in_filepath_list = in_filepath.split(',')
+    if not download_dir:
+        download_dir = out_path
+    debug_path = os.fspath(out_path + "/debug.log")
+    debug_path = os.path.abspath(debug_path)
+
+    debug_file = Path(debug_path)
+    debug_file.parent.mkdir(exist_ok=True, parents=True)
+    logfile = open(debug_path, "w")
+
+    debug_file_path = os.path.join(out_path, "debug.log")
+
+    if debug_level is not None:
+        setup_logger("default", debug_file_path, LEVELS[debug_level])
+    elif "pydevd" in sys.modules:
+        setup_logger("default", debug_file_path, logging.DEBUG)
+    else:
+        setup_logger("default", debug_file_path, logging.INFO)
+    file_content = []
+    files = []
+    for in_filepath in in_filepath_list:
+        pre, ext = os.path.splitext(in_filepath)
+
+        if out_path is None:
+            # if output file path not specified, just chagne the extension
+            out_path = os.path.dirname(pre)
+
+
+        if os.path.isdir(in_filepath):
+            files = [
+                os.path.join(in_filepath, f)
+                for f in os.listdir(in_filepath) 
+                if f.endswith(".drawio")
+            ]
+        elif os.path.isfile(in_filepath) and in_filepath.endswith(".drawio"):
+            files = [in_filepath]
+            
+        for f in files:
+            with open(f, 'r') as s:
+                content = s.read()
+                # present issue with some drawio file that miss the XML header
+
+                file_content.append(content)
+    if not file_content:
+        logger.critical(f"{in_filepath} is neither a drawio file nor a directory containing drawio files")
+        exit(1)
+
+
+    strategy = globals()[input_strategy](files)
+    logger.info(f"build the graph from strategy {input_strategy}")
+    media_path = os.path.join(out_path, "media-tmp")
+    project = strategy.execute(file_content, media_path)
+
+    strategy = globals()[output_strategy](project, out_path)
+
+    logger.info("Using strategy {}".format(strategy.__class__))
+    logger.info("update the node with basic information")
+    # create constraints, clean name
+
+    output = strategy.execute()
+
+    # compress the output folder to a zip archieve and place it in the download directory
+    # shutil.make_archive(os.path.join(download_dir), "zip", os.path.join(out_path))
+
+    # if trad:
+    # langs.to_po_file("./trad.po")

tests/test_cql.py

@@ -0,0 +1,197 @@
+import unittest
+
+from tricc_oo.converters.cql_to_operation import cqlToXlsFormVisitor, transform_cql_to_operation
+from tricc_oo.models.base import  TriccOperator, TriccOperation, TriccStatic, TriccReference
+
+class TestCql(unittest.TestCase):
+    def test_and(self):
+        if_cql = "\"p_weight\" is not null and \"p_age\" > 2"
+        dg_operation = transform_cql_to_operation(if_cql)
+        dg_expected = TriccOperation(
+            operator=TriccOperator.AND,
+            reference=[
+                TriccOperation(
+                    operator=TriccOperator.NOT,
+                    reference=[
+                        TriccOperation(
+                            operator=TriccOperator.ISNULL,
+                            reference=[TriccReference("p_weight")]
+                        )
+                    ]
+                ),
+                TriccOperation(
+                    operator=TriccOperator.MORE,
+                    reference=[
+                        TriccReference("p_age"),
+                        TriccStatic(
+                            value=2
+                        )
+                    ]
+                )
+            ]
+        )
+        self.assertEqual(str(dg_operation), str(dg_expected))
+    
+   
+    def test_durg_doage(self):
+        if_cql = "DrugDosage('paracetamol', \"p_weight\", \"p_age\")"
+        dg_operation = transform_cql_to_operation(if_cql)
+        dg_expected = TriccOperation(
+            operator=TriccOperator.DRUG_DOSAGE,
+            reference=[
+                TriccStatic(value='paracetamol'),
+                TriccReference("p_weight"),
+                TriccReference("p_age")
+            ]
+        )
+        self.assertEqual(str(dg_operation), str(dg_expected))
+    
+    def test_if(self):
+        if_cql = "if AgeInDays() < 60 then 'newborn' else 'child'"
+        if_operation = transform_cql_to_operation(if_cql)
+        if_expected = TriccOperation(
+            operator=TriccOperator.IF,
+            reference=[
+                TriccOperation(
+                    operator=TriccOperator.LESS,
+                    reference=[
+                        TriccOperation(
+                            operator=TriccOperator.AGE_DAY,
+                            reference=[]
+                        ),
+                        TriccStatic(
+                            value=60
+                        )
+                    ]
+                ),
+                TriccStatic(value='newborn'),
+                TriccStatic(value='child'),
+            ]
+        )
+        self.assertEqual(str(if_operation), str(if_expected))
+
+    def test_case(self):
+        case_cql = """
+        case AgeInMonths() 
+        when 0 then 'newborn' 
+        when 1 then 'newborn' 
+        else 'child' end
+        """
+        case_operation = transform_cql_to_operation(case_cql)
+        case_expected = TriccOperation(
+            operator=TriccOperator.CASE,
+            reference=[
+                TriccOperation(
+                    operator=TriccOperator.AGE_MONTH,
+                    reference=[]
+                ),
+                [
+                    TriccStatic(
+                        value=0
+                    ),
+                    TriccStatic(
+                        value="newborn"
+                    )
+                ],
+                [
+                    TriccStatic(
+                        value=1
+                    ),
+                    TriccStatic(
+                        value="newborn"
+                    )
+                ],
+                TriccStatic(value='child'),
+            ]
+        )
+        self.assertEqual(str(case_operation), str(case_expected))
+
+    def test_ifs(self):
+        case_cql = """
+        case 
+        when AgeInMonths() <= 2 then true
+        when AgeInYears() > 5 then true
+        else false end
+        """
+        case_operation = transform_cql_to_operation(case_cql)
+        case_expected = TriccOperation(
+            operator=TriccOperator.CASE,
+            reference=[
+                [
+                    TriccOperation(
+                        operator=TriccOperator.LESS_OR_EQUAL,
+                        reference=[
+                            TriccOperation(
+                                operator=TriccOperator.AGE_MONTH,
+                                reference=[]
+                            ),
+                            TriccStatic(
+                                value=2
+                            )
+                        ]
+                    ),
+                    TriccStatic(
+                        value=True
+                    )
+                ],
+                [
+                    TriccOperation(
+                        operator=TriccOperator.MORE,
+                        reference=[
+                            TriccOperation(
+                                operator=TriccOperator.AGE_YEAR,
+                                reference=[]
+                            ),
+                            TriccStatic(
+                                value=5
+                            )
+                        ]
+                    ),
+                    TriccStatic(
+                        value=True
+                    )
+                ],
+                TriccStatic(value=False),
+            ]
+        )
+        self.assertEqual(str(case_operation), str(case_expected))
+
+
+    def test_minus(self):
+        minus_cql =""" "WFL" >= -3"""
+        # minus_cql = """
+        # ("age_in_months" < 6 and "WFL" >= -3 and "WFL" < -2) is true
+        # """
+        minus_operation = transform_cql_to_operation(minus_cql)
+        minus_expected = TriccOperation(
+            TriccOperator.MORE_OR_EQUAL,
+            [
+                TriccReference("WFL"),
+                TriccOperation(
+                    TriccOperator.MINUS,
+                    [TriccStatic(3)]
+                )
+            ]
+        )
+        self.assertEqual(str(minus_operation), str(minus_expected))
+
+    def test_not_in(self):
+        not_in_cql = "'code' not in \"identifier\""
+        dg_operation = transform_cql_to_operation(not_in_cql)
+        dg_expected = TriccOperation(
+            operator=TriccOperator.NOT,
+            reference=[
+                TriccOperation(
+                    operator=TriccOperator.SELECTED,
+                    reference=[
+                        TriccReference("identifier"),
+                        TriccStatic(value='code'),
+                    ]
+                )
+            ]
+        )
+        self.assertEqual(str(dg_operation), str(dg_expected))
+    
+
+if __name__ == '__main__':
+    unittest.main()

tests/to_ocl.py

@@ -0,0 +1,51 @@
+import os
+import json
+from pathlib import Path
+from tricc_oo.converters.codesystem_to_ocl import transform_fhir_to_ocl
+
+def find_and_process_codesystems(directory_path):
+    # Convert string path to Path object if not already
+    dir_path = Path(directory_path)
+    
+    # Find all JSON files in the directory
+    for json_file in dir_path.glob("*.json"):
+        try:
+            # Read the JSON file
+            with open(json_file, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+                
+                # Check if resource_type is CodeSystem
+                if data.get("resourceType") == "CodeSystem":
+                    # Get the filename without extension for output naming
+                    file_key = json_file.stem
+                    
+                    # Write the original CodeSystem JSON
+                    output_cs_path = dir_path / f"{file_key}_codesystem.json"
+                    with open(output_cs_path, "w", encoding='utf-8') as file:
+                        file.write(json.dumps(data, indent=4))
+                    
+                    # Transform to OCL payload
+                    ocl_payload = transform_fhir_to_ocl(
+                        data,
+                        source_name="ALM",
+                        source_owner="pdelcroix",
+                        source_owner_type="User"
+                    )
+                    
+                    # Save the transformed OCL payload
+                    output_ocl_path = dir_path / f"{file_key}_ocl_bulk_upload.json"
+                    with open(output_ocl_path, "w", encoding='utf-8') as f:
+                        for item in ocl_payload:
+                            json_line = json.dumps(item.dict(exclude_none=True))
+                            f.write(json_line + '\n')
+                    
+                    print(f"OCL bulk upload payload generated successfully for {file_key}!")
+                    
+        except json.JSONDecodeError:
+            print(f"Error: Invalid JSON in file {json_file}")
+        except Exception as e:
+            print(f"Error processing {json_file}: {str(e)}")
+
+# Example usage
+media_path = "path/to/your/directory"  # Replace with your directory path
+find_and_process_codesystems(media_path)

{tricc → tricc_oo}/__init__.py

@@ -4,8 +4,10 @@ pyfhirsdc is a ython library that converts XLS to Fhir SDC ressource.
 Collect easy.
 """
 
-__version__ = "0.0.0"
+__version__ = "1.0.2"
 
+from .models.base import *
+from .models.calculate import *
 from .models.tricc import *
 from .serializers import *
 

tricc_oo/converters/codesystem_to_ocl.py

@@ -0,0 +1,169 @@
+from typing import Dict, List, Any
+import json
+from fhir.resources.codesystem import CodeSystem
+from tricc_oo.models.ocl import (
+    OCLConcept,
+    OCLSource,
+    OCLDetailedName,
+    OCLDetailedDescription,
+    OclConstants,
+    get_data_type
+)
+
+def extract_properties_metadata(fhir_cs: CodeSystem) -> Dict[str, Dict]:
+    """
+    Extracts property definitions from FHIR CodeSystem and converts them to OCL attribute types
+    """
+    property_types = {}
+    if hasattr(fhir_cs, 'property') and fhir_cs.property:
+        for prop in fhir_cs.property:
+            # Map FHIR property types to OCL datatypes
+            fhir_type = prop.type
+            ocl_type = {
+                "code": "Text",
+                "Coding": "Concept",
+                "boolean": "Boolean",
+                "decimal": "Numeric",
+                "integer": "Numeric",
+                "dateTime": "DateTime",
+                "string": "Text"
+            }.get(fhir_type, "Text")
+            
+            property_types[prop.code] = {
+                "name": prop.code,
+                "datatype": ocl_type,
+                "description": prop.description if hasattr(prop, 'description') else ""
+            }
+    return property_types
+
+def get_fhir_concept_datatype(concept):
+    
+    datatype = extract_concept_properties(concept, ['datatype'])
+    if datatype:
+        return datatype['datatype']
+    else:
+        return OclConstants.DATA_TYPE_NONE
+
+def extract_concept_properties(concept, property_types: List) -> List[Dict]:
+    """
+    Extracts properties from a FHIR concept and converts them to OCL attributes
+    """
+    properties = {}
+    if hasattr(concept, 'property') and concept.property:
+        for prop in concept.property:
+            if prop.code in property_types:
+                # Handle different property value types
+                if getattr(prop, 'valueCode', None):
+                    value = prop.valueCode
+                elif getattr(prop, 'valueCoding', None):
+                    value = prop.valueCoding.code
+                elif getattr(prop, 'valueString', None):
+                    value = prop.valueString
+                elif getattr(prop, 'valueBoolean', None):
+                    value = prop.valueBoolean
+                elif getattr(prop, 'valueInteger', None):
+                    value = prop.valueInteger
+                elif getattr(prop, 'valueDecimal', None):
+                    value = prop.valueDecimal
+                elif getattr(prop, 'valueDateTime', None):
+                    value = prop.valueDateTime
+                else:
+                    continue
+                if value:
+                    properties[prop.code] = value
+    return properties
+                
+                
+def get_attributes_from_concept_properties(concept, property_types: Dict) -> List[Dict]:
+    attributes = []
+    properties = extract_concept_properties(concept, property_types=list(property_types))
+    for code, value in properties.items():
+        attributes.append({
+            "type": "Attribute",
+            "attribute_type": code,
+            "value": value,
+            "value_type": property_types[code]["datatype"]
+        })
+    return attributes
+
+def transform_fhir_to_ocl(fhir_codesystem_json: Dict, source_name: str, source_owner: str, source_owner_type: str) -> List[Dict[str, Any]]:
+    """
+    Transforms a FHIR CodeSystem resource into an OCL bulk upload JSON payload.
+    
+    Args:
+        fhir_codesystem_json: JSON representation of the FHIR CodeSystem resource
+        source_name: Name of the OCL Source
+        source_owner: Owner of the OCL Source (organization or user)
+        source_owner_type : User or Organization
+    
+    Returns:
+        List of dictionaries representing OCL bulk upload format
+    """
+    # Load the FHIR CodeSystem
+    fhir_cs = CodeSystem.parse_obj(fhir_codesystem_json)
+
+    # Extract property definitions
+    property_types = extract_properties_metadata(fhir_cs)
+
+    # Initialize OCL payload
+    ocl_payload = []
+
+    # Add source metadata
+
+    
+    # Add property definitions to extras
+    if property_types:
+        source_extras["attribute_types"] = list(property_types.values())
+
+    ocl_payload.append(
+        OCLSource(
+            short_code=source_name,
+            id=source_name,
+            canonical_url=fhir_cs.url,
+            owner=source_owner,
+            owner_type=source_owner_type,
+            name=fhir_cs.name or "Unnamed Source",
+            full_name=fhir_cs.title if hasattr(fhir_cs, 'title') else fhir_cs.name,
+            description=fhir_cs.description or "",
+            source_type="Dictionary",
+            default_locale="en",
+            supported_locales=["en"],
+        )
+      )
+
+    # Transform concepts
+    if hasattr(fhir_cs, 'concept') and fhir_cs.concept:
+        for concept in fhir_cs.concept:
+            datatype = get_fhir_concept_datatype(concept)
+            ocl_concept = OCLConcept(
+                id=concept.code,
+                concept_class="Misc",
+                datatype=datatype,
+                owner=source_owner,  # Added owner
+                owner_type=source_owner_type,
+                source=source_name,  # Added source
+                names=[
+                    OCLDetailedName(
+                        name=concept.display,
+                        locale="en",
+                        name_type=OclConstants.NAME_TYPE_FULLY_SPECIFIED,
+                    )
+                ],
+                descriptions=[]
+            )
+
+            # Add definition if present
+            if hasattr(concept, 'definition') and concept.definition:
+                ocl_concept.descriptions.append(OCLDetailedDescription(
+                    description=concept.definition,
+                    locale="en",
+                ))
+
+            # Extract and add properties as attributes
+            attributes = get_attributes_from_concept_properties(concept, property_types)
+            if attributes:
+                ocl_concept["attributes"] = attributes
+
+            ocl_payload.append(ocl_concept)
+
+    return ocl_payload