tricc-oo 1.6.25__py3-none-any.whl → 1.7.0.dev1__py3-none-any.whl

tricc_oo/strategies/output/xls_form.py

@@ -8,7 +8,6 @@ import logging
 import os
 import re
 import pandas as pd
-from pyxform import create_survey_from_xls
 
 from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.base import (
@@ -19,16 +18,14 @@ from tricc_oo.models.ordered_set import OrderedSet
 from tricc_oo.models.calculate import (
     TriccNodeEnd,
     TriccNodeDisplayCalculateBase,
-    TriccNodeActivityStart,
+
 )
 from tricc_oo.models.tricc import (
     TriccNodeCalculateBase,
     TriccNodeBaseModel,
     TriccNodeSelectOption,
-    TriccNodeSelect,
     TriccNodeInputModel,
     TriccNodeDisplayModel,
-    TriccNodeMainStart,
     TRICC_FALSE_VALUE,
     TRICC_TRUE_VALUE,
 )
@@ -51,8 +48,6 @@ from tricc_oo.serializers.xls_form import (
     SURVEY_MAP,
     end_group,
     generate_xls_form_export,
-    get_export_group_name,
-    get_export_group_required,
     start_group,
 )
 from tricc_oo.strategies.output.base_output_strategy import BaseOutPutStrategy
@@ -91,8 +86,6 @@ OPERATOR_COALESCE_FALLBACK = {
     TriccOperator.MORE_OR_EQUAL: -2147483648,
     TriccOperator.LESS: 2147483647,
     TriccOperator.LESS_OR_EQUAL: 2147483647,
-    TriccOperator.CONTAINS: "''",
-    TriccOperator.SELECTED: "''",
 }
 
 
@@ -380,14 +373,12 @@ 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 = [
                     (
@@ -408,43 +399,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, original_references)
+            return callable(ref_expressions)
         else:
             raise NotImplementedError(
                 f"This type of opreation '{operation.operator}' is not supported in this strategy"
             )
 
-    def tricc_operation_count(self, ref_expressions, original_references=None):
+    def tricc_operation_count(self, ref_expressions):
         return f"count-selected({self.clean_coalesce(ref_expressions[0])})"
 
-    def tricc_operation_multiplied(self, ref_expressions, original_references=None):
-        return "*".join(map(str, ref_expressions))
+    def tricc_operation_multiplied(self, ref_expressions):
+        return "*".join(map(str,ref_expressions))
 
-    def tricc_operation_divided(self, ref_expressions, original_references=None):
+    def tricc_operation_divided(self, ref_expressions):
         return f"{ref_expressions[0]} div {ref_expressions[1]}"
 
-    def tricc_operation_modulo(self, ref_expressions, original_references=None):
+    def tricc_operation_modulo(self, ref_expressions):
         return f"{ref_expressions[0]} mod {ref_expressions[1]}"
 
-    def tricc_operation_coalesce(self, ref_expressions, original_references=None):
+    def tricc_operation_coalesce(self, ref_expressions):
         return f"coalesce({','.join(map(self.clean_coalesce, ref_expressions))})"
 
-    def tricc_operation_module(self, ref_expressions, original_references=None):
+    def tricc_operation_module(self, ref_expressions):
         return f"{ref_expressions[0]} mod {ref_expressions[1]}"
 
-    def tricc_operation_minus(self, ref_expressions, original_references=None):
+    def tricc_operation_minus(self, ref_expressions):
         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, original_references=None):
-        return " + ".join(map(str, ref_expressions))
+    def tricc_operation_plus(self, ref_expressions):
+        return " + ".join(map(str,ref_expressions))
 
-    def tricc_operation_not(self, ref_expressions, original_references=None):
+    def tricc_operation_not(self, ref_expressions):
         return f"not({ref_expressions[0]})"
 
-    def tricc_operation_and(self, ref_expressions, original_references=None):
+    def tricc_operation_and(self, ref_expressions):
         if len(ref_expressions) == 1:
             return ref_expressions[0]
         if len(ref_expressions) > 1:
@@ -456,7 +447,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return "1"
 
-    def tricc_operation_or(self, ref_expressions, original_references=None):
+    def tricc_operation_or(self, ref_expressions):
         if len(ref_expressions) == 1:
             return ref_expressions[0]
         if len(ref_expressions) > 1:
@@ -468,7 +459,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return "1"
 
-    def tricc_operation_native(self, ref_expressions, original_references=None):
+    def tricc_operation_native(self, ref_expressions):
 
         if len(ref_expressions) > 0:
             if ref_expressions[0].startswith(("'", "`",)):
@@ -483,82 +474,77 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 return "0"
                 # return f"jr:choice-name({','.join(ref_expressions[1:])})"
             else:
-                return f"{ref_expressions[0]}({','.join(map(str, ref_expressions[1:]))})"
+                return f"{ref_expressions[0]}({','.join(map(str,ref_expressions[1:]))})"
 
-    def tricc_operation_istrue(self, ref_expressions, original_references=None):
+    def tricc_operation_istrue(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_isfalse(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_parenthesis(self, ref_expressions):
         return f"({ref_expressions[0]})"
 
-    def tricc_operation_selected(self, ref_expressions, original_references=None):
+    def tricc_operation_selected(self, ref_expressions):
         parts = []
         for s in ref_expressions[1:]:
             # for option with numeric value
-            if isinstance(s, str):
-                cleaned_s = s
-            elif isinstance(s, TriccNodeSelectOption):
-                cleaned_s = s.name
-            else:
-                cleaned_s = "'" + str(s) + "'"
+            cleaned_s = s if isinstance(s, str) else "'" + str(s) + "'"
             parts.append(f"selected({self.clean_coalesce(ref_expressions[0])}, {cleaned_s})")
         if len(parts) == 1:
             return parts[0]
         else:
             return self.tricc_operation_or(parts)
 
-    def tricc_operation_more_or_equal(self, ref_expressions, original_references=None):
+    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, original_references=None):
+    def tricc_operation_less_or_equal(self, ref_expressions):
         return f"{ref_expressions[0]}<={ref_expressions[1]}"
 
-    def tricc_operation_more(self, ref_expressions, original_references=None):
+    def tricc_operation_more(self, ref_expressions):
         return f"{ref_expressions[0]}>{ref_expressions[1]}"
 
-    def tricc_operation_less(self, ref_expressions, original_references=None):
+    def tricc_operation_less(self, ref_expressions):
         return f"{ref_expressions[0]}<{ref_expressions[1]}"
 
-    def tricc_operation_between(self, ref_expressions, original_references=None):
+    def tricc_operation_between(self, ref_expressions):
         return f"{ref_expressions[0]}>={ref_expressions[1]} and {ref_expressions[0]} < {ref_expressions[2]}"
 
-    def tricc_operation_equal(self, ref_expressions, original_references=None):
+    def tricc_operation_equal(self, ref_expressions):
         return f"{ref_expressions[0]}={ref_expressions[1]}"
 
-    def tricc_operation_not_equal(self, ref_expressions, original_references=None):
+    def tricc_operation_not_equal(self, ref_expressions):
         return f"{ref_expressions[0]}!={ref_expressions[1]}"
 
-    def tricc_operation_isnull(self, ref_expressions, original_references=None):
+    def tricc_operation_isnull(self, ref_expressions):
         return f"{ref_expressions[0]}=''"
 
-    def tricc_operation_isnotnull(self, ref_expressions, original_references=None):
+    def tricc_operation_isnotnull(self, ref_expressions):
         return f"{ref_expressions[0]}!=''"
 
-    def tricc_operation_isnottrue(self, ref_expressions, original_references=None):
+    def tricc_operation_isnottrue(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_isnotfalse(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_notexist(self, ref_expressions):
         return f"{ref_expressions[0]}=''"
 
-    def tricc_operation_case(self, ref_expressions, original_references=None):
+    def tricc_operation_case(self, ref_expressions):
         ifs = 0
         parts = []
         else_found = False
@@ -581,7 +567,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             exp += ")"
         return exp
 
-    def tricc_operation_ifs(self, ref_expressions, original_references=None):
+    def tricc_operation_ifs(self, ref_expressions):
         ifs = 0
         parts = []
         else_found = False
@@ -606,19 +592,19 @@ class XLSFormStrategy(BaseOutPutStrategy):
     def get_empty_label(self):
         return "."
 
-    def tricc_operation_if(self, ref_expressions, original_references=None):
+    def tricc_operation_if(self, ref_expressions):
         return f"if({ref_expressions[0]},{ref_expressions[1]},{ref_expressions[2]})"
 
-    def tricc_operation_contains(self, ref_expressions, original_references=None):
+    def tricc_operation_contains(self, ref_expressions):
         return f"contains({self.clean_coalesce(ref_expressions[0])}, {self.clean_coalesce(ref_expressions[1])})"
 
-    def tricc_operation_exists(self, ref_expressions, original_references=None):
+    def tricc_operation_exists(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_cast_number(self, ref_expressions):
         if isinstance(
             ref_expressions[0],
             (
@@ -645,7 +631,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return f"number({ref_expressions[0]})"
 
-    def tricc_operation_cast_integer(self, ref_expressions, original_references=None):
+    def tricc_operation_cast_integer(self, ref_expressions):
         if isinstance(
             ref_expressions[0],
             (
@@ -672,18 +658,18 @@ class XLSFormStrategy(BaseOutPutStrategy):
         else:
             return f"int({ref_expressions[0]})"
 
-    def tricc_operation_zscore(self, ref_expressions, original_references=None):
+    def tricc_operation_zscore(self, ref_expressions):
         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, original_references=None):
+    def tricc_operation_datetime_to_decimal(self, ref_expressions):
         return f"decimal-date-time({ref_expressions[0]})"
 
-    def tricc_operation_round(self, ref_expressions, original_references=None):
+    def tricc_operation_round(self, ref_expressions):
         return f"round({ref_expressions[0]})"
 
-    def tricc_operation_izscore(self, ref_expressions, original_references=None):
+    def tricc_operation_izscore(self, ref_expressions):
         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})"
@@ -702,7 +688,6 @@ 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,
@@ -739,89 +724,20 @@ class XLSFormStrategy(BaseOutPutStrategy):
         # @param r reference to be translated
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(r)
-        elif isinstance(r, (TriccStatic, str, int, float)):
-            return get_export_name(r)
         elif isinstance(r, TriccReference):
             logger.warning(f"reference `{r.value}` still used in a calculate")
             return f"${{{get_export_name(r.value)}}}"
-
+        elif isinstance(r, (TriccStatic, str, int, float)):
+            return get_export_name(r)
         elif isinstance(r, TriccNodeSelectOption):
             logger.debug(f"select option {r.get_name()} from {r.select.get_name()} was used as a reference")
             return get_export_name(r)
-        elif isinstance(r, TriccNodeActivityStart):
-            if get_export_group_required(r.activity):
-                return f"${{{get_export_group_name(r.activity)}}}"
-            else:
-                return f"({self.get_tricc_operation_expression(r.relevance)})"
-        elif isinstance(r, TriccNodeMainStart):
-            return "1"
-        elif issubclass(r.__class__, (TriccNodeInputModel, TriccNodeSelect)):
+        elif issubclass(r.__class__, TriccNodeInputModel):
             return f"coalesce(${{{get_export_name(r)}}},{coalesce_fallback})"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             return f"${{{get_export_name(r)}}}"
         else:
             raise NotImplementedError(f"This type of node {r.__class__} is not supported within an operation")
 
-    def tricc_operation_concatenate(self, ref_expressions, original_references=None):
+    def tricc_operation_concatenate(self, ref_expressions):
         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:
-            # Determine the XLS file path
-            if self.project.start_pages["main"].root.form_id is not None:
-                form_id = str(self.project.start_pages["main"].root.form_id)
-                xls_path = os.path.join(self.output_path, form_id + ".xlsx")
-
-                if not os.path.exists(xls_path):
-                    logger.error(f"XLS file not found: {xls_path}")
-                    return False
-
-                # Validate using pyxform
-                survey = create_survey_from_xls(xls_path)
-                xml_output = survey.to_xml()
-
-                # Check if XML was generated successfully
-                if xml_output and len(xml_output.strip()) > 0:
-                    logger.info("XLSForm validation successful")
-                    return True
-                else:
-                    logger.error("XLSForm validation failed: Empty XML output")
-                    return False
-            else:
-                logger.error("Form ID not found for validation")
-                return False
-        except Exception as e:
-            logger.error(f"XLSForm validation failed: {str(e)}")
-            return False

tricc_oo/strategies/output/xlsform_cht.py

@@ -2,13 +2,8 @@ import datetime
 import logging
 import os
 import shutil
-import subprocess
-import tempfile
-import zipfile
 import pandas as pd
 
-from pyxform.xls2xform import convert
-
 from tricc_oo.models.lang import SingletonLangClass
 from tricc_oo.models.calculate import TriccNodeEnd
 from tricc_oo.models.tricc import TriccNodeDisplayModel
@@ -621,9 +616,6 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         newpath = os.path.join(self.output_path, newfilename)
         media_path = os.path.join(self.output_path, form_id + "-media")
 
-        # Track all generated XLS files for validation
-        generated_files = [newpath]
-
         settings = {
             "form_title": title,
             "form_id": form_id,
@@ -640,7 +632,6 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         df_settings.to_excel(writer, sheet_name="settings", index=False)
         writer.close()
         # pause
-        logger.info("generating the task and after pause questionnaires")
         ends = []
         for p in self.project.pages.values():
             p_ends = list(
@@ -669,7 +660,6 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 new_form_id = f"{form_id}_{clean_name(e.name)}"
                 newfilename = f"{new_form_id}.xlsx"
                 newpath = os.path.join(self.output_path, newfilename)
-                generated_files.append(newpath)  # Track additional XLS files
                 settings = {
                     "form_title": title,
                     "form_id": f"{new_form_id}",
@@ -718,122 +708,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 shutil.move(os.path.join(media_path_tmp, file_name), media_path)
             shutil.rmtree(media_path_tmp)
 
-        return generated_files
-
-    def execute(self):
-        """Override execute to handle multiple output files from CHT strategy."""
-        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")
-
-        # create relevance Expression
-
-        # create calculate Expression
-        self.process_calculate(self.project.start_pages, pages=self.project.pages)
-        logger.info("generate the export format")
-        # create calculate Expression
-        self.process_export(self.project.start_pages, pages=self.project.pages)
-
-        logger.info("print the export")
-
-        # Export returns list of generated files for CHT strategy
-        generated_files = self.export(self.project.start_pages, version=version)
-
-        logger.info("validate the output")
-        if not self.validate(generated_files):
-            logger.error("CHT validation failed - aborting build")
-            exit(1)
-
-    def validate(self, generated_files=None):
-        """Validate the generated XLS form(s) using pyxform conversion and ODK Validate JAR."""
-        if generated_files is None:
-            # Fallback for single file validation
-            if self.project.start_pages["main"].root.form_id is not None:
-                form_id = str(self.project.start_pages["main"].root.form_id)
-                generated_files = [os.path.join(self.output_path, form_id + ".xlsx")]
-            else:
-                logger.error("Form ID not found for validation")
-                return False
-
-        # Ensure ODK Validate JAR is available
-        jar_path = self._ensure_odk_validate_jar()
-        if not jar_path:
-            logger.error("ODK Validate JAR not available, skipping CHT validation")
-            return False
-
-        all_valid = True
-        for xls_file in generated_files:
-            if not os.path.exists(xls_file):
-                logger.error(f"XLS file not found: {xls_file}")
-                all_valid = False
-                continue
-
-            try:
-                # Convert XLS to XForm using pyxform (without validation)
-                xform_path = xls_file.replace('.xlsx', '.xml')
-                convert_result = convert(
-                    xlsform=xls_file,
-                    validate=False,  # Don't validate during conversion
-                    pretty_print=True
-                )
-                xform_content = convert_result.xform
-
-                # Write XForm to temporary file for validation
-                with tempfile.NamedTemporaryFile(mode='w', suffix='.xml', delete=False) as temp_file:
-                    temp_file.write(xform_content)
-                    temp_xform_path = temp_file.name
-
-                try:
-                    # Run ODK Validate JAR on the XForm
-                    result = subprocess.run(
-                        ["java", "-Djava.awt.headless=true", "-jar", jar_path, temp_xform_path],
-                        capture_output=True,
-                        text=True,
-                        cwd=self.output_path
-                    )
-
-                    if result.returncode == 0 or "Cycle detected" in result.stderr:
-                        logger.info(f"CHT XLSForm validation successful: {os.path.basename(xls_file)}")
-                    else:
-                        logger.error(f"CHT XLSForm validation failed for {os.path.basename(xls_file)}: {result.stderr}")
-                        all_valid = False
-
-                finally:
-                    # Clean up temporary XForm file
-                    os.unlink(temp_xform_path)
-
-            except Exception as e:
-                logger.error(f"CHT XLSForm validation error for {os.path.basename(xls_file)}: {str(e)}")
-                all_valid = False
-
-            logger.info(f"Extracted ODK Validate JAR to {jar_path}")
-            return jar_path
-
-    def _ensure_odk_validate_jar(self):
-        """Ensure ODK Validate JAR is available by downloading from GitHub releases."""
-        jar_path = os.path.join(os.path.dirname(__file__), "ODK_Validate.jar")
-
-        # Check if JAR already exists
-        if os.path.exists(jar_path):
-            return jar_path
-
-        # Download JAR from GitHub releases
-        jar_url = "https://github.com/getodk/validate/releases/download/v1.20.0/ODK-Validate-v1.20.0.jar"
-        try:
-            import urllib.request
-            urllib.request.urlretrieve(jar_url, jar_path)
-            logger.info(f"Downloaded ODK Validate JAR to {jar_path}")
-            return jar_path
-        except Exception as e:
-            logger.error(f"Failed to download ODK Validate JAR: {str(e)}")
-            return None
-
-    def tricc_operation_zscore(self, ref_expressions, original_references=None):
+    def tricc_operation_zscore(self, ref_expressions):
         y, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return ((Math.pow((y / m), l) - 1) / (s * l));
         return f"""cht:extension-lib('{
@@ -846,7 +721,7 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[3])
             })"""
 
-    def tricc_operation_izscore(self, ref_expressions, original_references=None):
+    def tricc_operation_izscore(self, ref_expressions):
         z, ll, m, s = self.get_zscore_params(ref_expressions)
         #  return  (m * (z*s*l-1)^(1/l));
         return f"""cht:extension-lib('{
@@ -857,9 +732,9 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
             self.clean_coalesce(ref_expressions[2])
             } ,{
             self.clean_coalesce(ref_expressions[3])
-            }, true"""
+            }, true)"""
 
-    def tricc_operation_drug_dosage(self, ref_expressions, original_references=None):
+    def tricc_operation_drug_dosage(self, ref_expressions):
         # drug name
         # age
         # weight