tricc-oo 1.6.18__py3-none-any.whl → 1.6.19__py3-none-any.whl

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/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})"
@@ -747,35 +750,36 @@ 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):
+    def tricc_operation_diagnosis_list(self, ref_expressions, original_references=None):
         from tricc_oo.converters.datadictionnary import lookup_codesystems_code
+       
         parts = []
-        for expr in ref_expressions:
-            if isinstance(expr, str):
-                # expr is the variable reference like "final.TRIAGE_YELLOW" or "${var}"
-                if expr.startswith("${") and expr.endswith("}"):
-                    var_path = expr[2:-1]
-                else:
-                    var_path = expr
-                # Handle final. prefix
-                code = var_path[6:] if var_path.startswith("final.") else var_path
-                concept = lookup_codesystems_code(self.codesystems, code)
-                if concept:
-                    display = concept.get("display", code)
-                else:
-                    logger.warning(f"Diagnosis code '{code}' not found in codesystems")
-                    display = code
-                if expr.startswith("${"):
-                    condition = f"{expr} = 1"
-                else:
-                    condition = f"${{{expr}}} = 1"
-                # Always include comma after diagnosis name
-                parts.append(f"if({condition}, '{display},', '')")
+        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.warning(f"Unexpected expression type: {type(expr)}, value: {expr}")
+                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 "''"

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.18.dist-info → tricc_oo-1.6.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.6.18
+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.18.dist-info → tricc_oo-1.6.19.dist-info}/RECORD

@@ -5,7 +5,7 @@ tricc_oo/__init__.py,sha256=oWCE1ubmC_6iqaWOMgTei4eXVQgV202Ia-tXS1NnW_4,139
 tricc_oo/converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/converters/codesystem_to_ocl.py,sha256=V_oZNVUVaYHgzJtDiBMSrvIJnBWmDNFBDTTHEkOfpXk,6151
 tricc_oo/converters/cql_to_operation.py,sha256=1vNmGkI9OhGNTH6EH5hC1SnVVbIG5ps8dksGhZ0Vgw8,14543
-tricc_oo/converters/datadictionnary.py,sha256=JasqlLKiZzKdidsA1xc2SJ_Af1Xr6A3sKfzDynto8Ho,3686
+tricc_oo/converters/datadictionnary.py,sha256=JPcqjlohZJL1R6-fXzpFUNoOFe_W3OnG2uSjsOQN5-Y,3693
 tricc_oo/converters/drawio_type_map.py,sha256=Zp8J9iHNSJkIVrmRSM0_d4vA1X8wFPLKb8nCMPUMXKU,9114
 tricc_oo/converters/tricc_to_xls_form.py,sha256=39hwWgYNitGE-AuKtjUwNLz39tEpwc7nd9gT_gw5wjc,3842
 tricc_oo/converters/utils.py,sha256=JZrtrvvOfXwdkw49pKauzinOcauWwsy-CVcw36TjyLo,1684
@@ -36,16 +36,16 @@ tricc_oo/strategies/output/fhir_form.py,sha256=hbL921pe1Doun4IQrJuZ_Sq2fCh98G3gr
 tricc_oo/strategies/output/html_form.py,sha256=qSleEZOMV_-Z04y-i-ucyd5rgAYWAyjPwMrw0IHtCRM,8604
 tricc_oo/strategies/output/openmrs_form.py,sha256=ne6TwAyhafR-WDs27QTKKFl85VD5sij_VEJtK6ZjOIE,28996
 tricc_oo/strategies/output/spice.py,sha256=QMeoismVC3PdbvwTK0PtUjWX9jl9780fbQIXn76fMXw,10761
-tricc_oo/strategies/output/xls_form.py,sha256=93NEv8bZGWZWn28FxE_hwLf0yAGnL7ds6bS3rEDwcGQ,32319
+tricc_oo/strategies/output/xls_form.py,sha256=CafduxDYH88myZa471_d0Ya0FEPQV0ArS8zSdfTeY-k,33335
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=X00Lt5MzV8TX14dR4dFI1MqllI5S1e13bKbeysWM9uA,17435
-tricc_oo/strategies/output/xlsform_cht.py,sha256=0wrZ_Ez41D-SciXoBq4Pn4o1bK1ofUxXqbTjDoQuCGE,28597
+tricc_oo/strategies/output/xlsform_cht.py,sha256=lY1xIDxqYxl_lYNVCl3msXZL88No49yEVCpahcHGOn0,28675
 tricc_oo/strategies/output/xlsform_cht_hf.py,sha256=xm6SKirV3nMZvM2w54_zJcXAeAgAkq-EEqGEjnOWv6c,988
 tricc_oo/visitors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/visitors/tricc.py,sha256=ArvDNcuzIQNJpYyT1vB_B9Gxc2m5YAxg9ss_orpMqK0,111780
 tricc_oo/visitors/utils.py,sha256=j83aAq5s5atXi3OC0jc_uJd54a8XrHHmizeeEbWZQJg,421
 tricc_oo/visitors/xform_pd.py,sha256=ryAnI3V9x3eTmJ2LNsUZfvl0_yfCqo6oBgeSu-WPqaE,9613
-tricc_oo-1.6.18.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-tricc_oo-1.6.18.dist-info/METADATA,sha256=1nSbfCahrDBUlqaiuuarTmrJY9zgHmYgJKvG7_spR3s,8600
-tricc_oo-1.6.18.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-tricc_oo-1.6.18.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.6.18.dist-info/RECORD,,
+tricc_oo-1.6.19.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+tricc_oo-1.6.19.dist-info/METADATA,sha256=F67u0ot5zTwh4H5_-RJUCHXcEaGG3LITv2JsqH8woFE,8600
+tricc_oo-1.6.19.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tricc_oo-1.6.19.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.6.19.dist-info/RECORD,,