tricc-oo 1.6.16__tar.gz → 1.6.19__tar.gz

{tricc_oo-1.6.16/tricc_oo.egg-info → tricc_oo-1.6.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.16
+Version: 1.6.19
 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.6.16 → tricc_oo-1.6.19}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tricc-oo"
-version = "1.6.16"
+version = "1.6.19"
 description = "Python library that converts CDSS L2 in L3"
 readme = "README.md"
 requires-python = ">=3.8"

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tests/test_cql.py

@@ -26,6 +26,15 @@ class TestCql(unittest.TestCase):
         )
         self.assertEqual(str(dg_operation), str(dg_expected))
 
+    def test_diagnosis_list(self):
+        if_cql = 'DiagnosisList("final.TRIAGE_YELLOW", "triage_RED")'
+        dg_operation = transform_cql_to_operation(if_cql)
+        dg_expected = TriccOperation(
+            operator=TriccOperator.DIAGNOSIS_LIST,
+            reference=[TriccReference(value="final.TRIAGE_YELLOW"), TriccReference(value="triage_RED")],
+        )
+        self.assertEqual(str(dg_operation), str(dg_expected))
+
     def test_implied_concat(self):
         if_cql = "'A' & \"B\" & 'C'"
         cc_operation = transform_cql_to_operation(if_cql)

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tricc_oo/converters/cql_to_operation.py

@@ -37,6 +37,7 @@ FUNCTION_MAP = {
     "HasQualifier": TriccOperator.HAS_QUALIFIER,
     "DateTimeToDecimal": TriccOperator.DATETIME_TO_DECIMAL,
     "Count": TriccOperator.COUNT,
+    "DiagnosisList": TriccOperator.DIAGNOSIS_LIST,
 }
 # TODO
 # Min

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tricc_oo/converters/datadictionnary.py

@@ -101,7 +101,7 @@ def check_and_add_concept(code_system: CodeSystem, code: str, display: str, attr
         for p in new_concept.property:
             if p.code == k:
                 # TODO support other type of Codesystem Concept Property Value
-                existing_attributes
+                existing_attributes = True
                 if p.valueString != v:
                     logger.warning(f"conflicting value for concept `{concept.code}` property ` {k}`: {p.valueString} != {v}")
         if not existing_attributes:

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tricc_oo/models/base.py

@@ -377,6 +377,7 @@ class TriccOperator(StrEnum):
     PARENTHESIS = "parenthesis"
     CONCATENATE = "concatenate"
     DATETIME_TO_DECIMAL = "datetime_to_decimal"
+    DIAGNOSIS_LIST = "diagnosis_list"
 
 
 RETURNS_BOOLEAN = [
@@ -423,6 +424,8 @@ RETURNS_NUMBER = [
 
 RETURNS_DATE = [TriccOperator.CAST_DATE]
 
+RETURNS_STRING = [TriccOperator.DIAGNOSIS_LIST]
+
 OPERATION_LIST = {
     ">=": TriccOperator.MORE_OR_EQUAL,
     "<=": TriccOperator.LESS_OR_EQUAL,
@@ -480,6 +483,8 @@ class TriccOperation(BaseModel):
             return "number"
         elif self.operator in RETURNS_DATE:
             return "date"
+        elif self.operator in RETURNS_STRING:
+            return "string"
         elif self.operator == TriccOperator.CONCATENATE:
             return "string"
         elif self.operator == TriccOperator.PARENTHESIS:

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tricc_oo/strategies/output/xls_form.py

@@ -127,6 +127,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             "df_calculate": self.df_calculate,
             "calculates": self.calculates,
         }
+        
 
     def generate_export(self, node, **kwargs):
         return generate_xls_form_export(self, node, **kwargs)
@@ -374,12 +375,14 @@ class XLSFormStrategy(BaseOutPutStrategy):
 
     def get_tricc_operation_expression(self, operation):
         ref_expressions = []
+        original_references = []
         if not hasattr(operation, "reference"):
             return self.get_tricc_operation_operand(operation)
 
         operator = getattr(operation, "operator", "")
         coalesce_fallback = OPERATOR_COALESCE_FALLBACK[operator] if operator in OPERATOR_COALESCE_FALLBACK else "''"
         for r in operation.reference:
+            original_references.append(r)
             if isinstance(r, list):
                 r_expr = [
                     (
@@ -400,43 +403,43 @@ class XLSFormStrategy(BaseOutPutStrategy):
         # build lower level
         if hasattr(self, f"tricc_operation_{operation.operator}"):
             callable = getattr(self, f"tricc_operation_{operation.operator}")
-            return callable(ref_expressions)
+            return callable(ref_expressions, original_references)
         else:
             raise NotImplementedError(
                 f"This type of opreation '{operation.operator}' is not supported in this strategy"
             )
 
-    def tricc_operation_count(self, ref_expressions):
+    def tricc_operation_count(self, ref_expressions, original_references=None):
         return f"count-selected({self.clean_coalesce(ref_expressions[0])})"
 
-    def tricc_operation_multiplied(self, ref_expressions):
+    def tricc_operation_multiplied(self, ref_expressions, original_references=None):
         return "*".join(map(str, ref_expressions))
 
-    def tricc_operation_divided(self, ref_expressions):
+    def tricc_operation_divided(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]} div {ref_expressions[1]}"
 
-    def tricc_operation_modulo(self, ref_expressions):
+    def tricc_operation_modulo(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]} mod {ref_expressions[1]}"
 
-    def tricc_operation_coalesce(self, ref_expressions):
+    def tricc_operation_coalesce(self, ref_expressions, original_references=None):
         return f"coalesce({','.join(map(self.clean_coalesce, ref_expressions))})"
 
-    def tricc_operation_module(self, ref_expressions):
+    def tricc_operation_module(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]} mod {ref_expressions[1]}"
 
-    def tricc_operation_minus(self, ref_expressions):
+    def tricc_operation_minus(self, ref_expressions, original_references=None):
         if len(ref_expressions) > 1:
             return " - ".join(map(str, ref_expressions))
         elif len(ref_expressions) == 1:
             return f"-{ref_expressions[0]}"
 
-    def tricc_operation_plus(self, ref_expressions):
+    def tricc_operation_plus(self, ref_expressions, original_references=None):
         return " + ".join(map(str, ref_expressions))
 
-    def tricc_operation_not(self, ref_expressions):
+    def tricc_operation_not(self, ref_expressions, original_references=None):
         return f"not({ref_expressions[0]})"
 
-    def tricc_operation_and(self, ref_expressions):
+    def tricc_operation_and(self, ref_expressions, original_references=None):
         if len(ref_expressions) == 1:
             return ref_expressions[0]
         if len(ref_expressions) > 1:
@@ -448,7 +451,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return "1"
 
-    def tricc_operation_or(self, ref_expressions):
+    def tricc_operation_or(self, ref_expressions, original_references=None):
         if len(ref_expressions) == 1:
             return ref_expressions[0]
         if len(ref_expressions) > 1:
@@ -460,7 +463,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return "1"
 
-    def tricc_operation_native(self, ref_expressions):
+    def tricc_operation_native(self, ref_expressions, original_references=None):
 
         if len(ref_expressions) > 0:
             if ref_expressions[0].startswith(("'", "`",)):
@@ -477,22 +480,22 @@ class XLSFormStrategy(BaseOutPutStrategy):
             else:
                 return f"{ref_expressions[0]}({','.join(map(str, ref_expressions[1:]))})"
 
-    def tricc_operation_istrue(self, ref_expressions):
+    def tricc_operation_istrue(self, ref_expressions, original_references=None):
         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_isfalse(self, ref_expressions):
+    def tricc_operation_isfalse(self, ref_expressions, original_references=None):
         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_parenthesis(self, ref_expressions):
+    def tricc_operation_parenthesis(self, ref_expressions, original_references=None):
         return f"({ref_expressions[0]})"
 
-    def tricc_operation_selected(self, ref_expressions):
+    def tricc_operation_selected(self, ref_expressions, original_references=None):
         parts = []
         for s in ref_expressions[1:]:
             # for option with numeric value
@@ -508,49 +511,49 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return self.tricc_operation_or(parts)
 
-    def tricc_operation_more_or_equal(self, ref_expressions):
+    def tricc_operation_more_or_equal(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}>={ref_expressions[1]}"
 
-    def tricc_operation_less_or_equal(self, ref_expressions):
+    def tricc_operation_less_or_equal(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}<={ref_expressions[1]}"
 
-    def tricc_operation_more(self, ref_expressions):
+    def tricc_operation_more(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}>{ref_expressions[1]}"
 
-    def tricc_operation_less(self, ref_expressions):
+    def tricc_operation_less(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}<{ref_expressions[1]}"
 
-    def tricc_operation_between(self, ref_expressions):
+    def tricc_operation_between(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}>={ref_expressions[1]} and {ref_expressions[0]} < {ref_expressions[2]}"
 
-    def tricc_operation_equal(self, ref_expressions):
+    def tricc_operation_equal(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}={ref_expressions[1]}"
 
-    def tricc_operation_not_equal(self, ref_expressions):
+    def tricc_operation_not_equal(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}!={ref_expressions[1]}"
 
-    def tricc_operation_isnull(self, ref_expressions):
+    def tricc_operation_isnull(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}=''"
 
-    def tricc_operation_isnotnull(self, ref_expressions):
+    def tricc_operation_isnotnull(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}!=''"
 
-    def tricc_operation_isnottrue(self, ref_expressions):
+    def tricc_operation_isnottrue(self, ref_expressions, original_references=None):
         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):
+    def tricc_operation_isnotfalse(self, ref_expressions, original_references=None):
         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):
+    def tricc_operation_notexist(self, ref_expressions, original_references=None):
         return f"{ref_expressions[0]}=''"
 
-    def tricc_operation_case(self, ref_expressions):
+    def tricc_operation_case(self, ref_expressions, original_references=None):
         ifs = 0
         parts = []
         else_found = False
@@ -573,7 +576,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             exp += ")"
         return exp
 
-    def tricc_operation_ifs(self, ref_expressions):
+    def tricc_operation_ifs(self, ref_expressions, original_references=None):
         ifs = 0
         parts = []
         else_found = False
@@ -598,19 +601,19 @@ class XLSFormStrategy(BaseOutPutStrategy):
     def get_empty_label(self):
         return "."
 
-    def tricc_operation_if(self, ref_expressions):
+    def tricc_operation_if(self, ref_expressions, original_references=None):
         return f"if({ref_expressions[0]},{ref_expressions[1]},{ref_expressions[2]})"
 
-    def tricc_operation_contains(self, ref_expressions):
+    def tricc_operation_contains(self, ref_expressions, original_references=None):
         return f"contains({self.clean_coalesce(ref_expressions[0])}, {self.clean_coalesce(ref_expressions[1])})"
 
-    def tricc_operation_exists(self, ref_expressions):
+    def tricc_operation_exists(self, ref_expressions, original_references=None):
         parts = []
         for ref in ref_expressions:
             parts.append(self.tricc_operation_not_equal([self.tricc_operation_coalesce([ref, "''"]), "''"]))
         return self.tricc_operation_and(parts)
 
-    def tricc_operation_cast_number(self, ref_expressions):
+    def tricc_operation_cast_number(self, ref_expressions, original_references=None):
         if isinstance(
             ref_expressions[0],
             (
@@ -637,7 +640,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return f"number({ref_expressions[0]})"
 
-    def tricc_operation_cast_integer(self, ref_expressions):
+    def tricc_operation_cast_integer(self, ref_expressions, original_references=None):
         if isinstance(
             ref_expressions[0],
             (
@@ -664,18 +667,18 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return f"int({ref_expressions[0]})"
 
-    def tricc_operation_zscore(self, ref_expressions):
+    def tricc_operation_zscore(self, ref_expressions, original_references=None):
         y, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return ((Math.pow((y / m), l) - 1) / (s * l));
         return f"(pow({y} div ({m}), {ll}) -1) div (({s}) div ({ll}))"
 
-    def tricc_operation_datetime_to_decimal(self, ref_expressions):
+    def tricc_operation_datetime_to_decimal(self, ref_expressions, original_references=None):
         return f"decimal-date-time({ref_expressions[0]})"
 
-    def tricc_operation_round(self, ref_expressions):
+    def tricc_operation_round(self, ref_expressions, original_references=None):
         return f"round({ref_expressions[0]})"
 
-    def tricc_operation_izscore(self, ref_expressions):
+    def tricc_operation_izscore(self, ref_expressions, original_references=None):
         z, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return  (m * (z*s*l-1)^(1/l));
         return f"pow({m} * ({z} * {s} * {ll} -1), 1 div {ll})"
@@ -694,6 +697,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
     # @param left part
     # @param right part
     def generate_xls_form_calculate(self, node, processed_nodes, stashed_nodes, calculates, **kwargs):
+        self.codesystems = kwargs.get("codesystems", {})
         if is_ready_to_process(node, processed_nodes, strict=False) and process_reference(
             node,
             processed_nodes,
@@ -746,9 +750,40 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             raise NotImplementedError(f"This type of node {r.__class__} is not supported within an operation")
 
-    def tricc_operation_concatenate(self, ref_expressions):
+    def tricc_operation_concatenate(self, ref_expressions, original_references=None):
         return f"concat({','.join(map(str, ref_expressions))})"
 
+    def tricc_operation_diagnosis_list(self, ref_expressions, original_references=None):
+        from tricc_oo.converters.datadictionnary import lookup_codesystems_code
+       
+        parts = []
+        for i, orig_ref in enumerate(original_references):
+            expr = ref_expressions[i] if ref_expressions and i < len(ref_expressions) else None
+
+            code = None
+            # Use only original references for code lookup
+            if isinstance(orig_ref, TriccReference):
+                code = orig_ref.value
+            elif issubclass(type(orig_ref), TriccNodeBaseModel):
+                code = orig_ref.name
+            else:
+                logger.critical(f"Unexpected reference type: {type(orig_ref)}, value: {orig_ref}")
+                exit(1)
+
+            concept = lookup_codesystems_code(self.project.code_systems, code)
+            if concept:
+                display = getattr(concept, 'display', code)
+            else:
+                logger.warning(f"Diagnosis code '{code}' not found in codesystems")
+                display = code
+
+            # Always include comma after diagnosis name
+            parts.append(f"if({expr} = 1, '{display},', '')")
+
+        if parts:
+            return f"concat({','.join(parts)})"
+        return "''"
+
     def validate(self):
         """Validate the generated XLS form using pyxform."""
         try:

{tricc_oo-1.6.16 → tricc_oo-1.6.19}/tricc_oo/strategies/output/xlsform_cht.py

@@ -840,7 +840,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             logger.error(f"Failed to download ODK Validate JAR: {str(e)}")
             return None
 
-    def tricc_operation_zscore(self, ref_expressions):
+    def tricc_operation_zscore(self, ref_expressions, original_references=None):
         y, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return ((Math.pow((y / m), l) - 1) / (s * l));
         return f"""cht:extension-lib('{
@@ -853,7 +853,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[3])
             })"""
 
-    def tricc_operation_izscore(self, ref_expressions):
+    def tricc_operation_izscore(self, ref_expressions, original_references=None):
         z, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return  (m * (z*s*l-1)^(1/l));
         return f"""cht:extension-lib('{
@@ -866,7 +866,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[3])
             }, true"""
 
-    def tricc_operation_drug_dosage(self, ref_expressions):
+    def tricc_operation_drug_dosage(self, ref_expressions, original_references=None):
         # drug name
         # age
         # weight

{tricc_oo-1.6.16 → tricc_oo-1.6.19/tricc_oo.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.16
+Version: 1.6.19
 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