tricc-oo 1.6.6__tar.gz → 1.6.8__tar.gz

{tricc_oo-1.6.6/tricc_oo.egg-info → tricc_oo-1.6.8}/PKG-INFO

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

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

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/converters/tricc_to_xls_form.py

@@ -1,5 +1,5 @@
 import logging
-from tricc_oo.converters.utils import clean_name, clean_str
+from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.tricc import TriccNodeSelectOption, TRICC_TRUE_VALUE, TRICC_FALSE_VALUE, TriccNodeActivity
 from tricc_oo.models.calculate import TriccNodeInput
 from tricc_oo.models.base import TriccNodeBaseModel, TriccStatic, TriccReference
@@ -66,14 +66,13 @@ def get_export_name(node, replace_dots=True):
         return node
     else:
         node.gen_name()
-        if isinstance(node, TriccNodeActivity) and getattr(node, 'instance', 1)>1:
+        if isinstance(node, TriccNodeActivity) and getattr(node, 'instance', 1) > 1:
             node.export_name = clean_name(
                 node.name + INSTANCE_SEPARATOR + str(node.instance),
                 replace_dots=replace_dots,
             )
         elif isinstance(node, TriccNodeSelectOption):
             node.export_name = node.name
-            
         elif node.last is False:
             node.export_name = clean_name(
                 node.name + VERSION_SEPARATOR + str(node.version),

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/converters/xml_to_tricc.py

@@ -7,7 +7,7 @@ import re
 
 from tricc_oo.converters.utils import remove_html, clean_str
 from tricc_oo.converters.cql_to_operation import transform_cql_to_operation
-from tricc_oo.converters.utils import generate_id, get_rand_name
+from tricc_oo.converters.utils import generate_id
 from tricc_oo.models.base import (
     TriccOperator, TriccOperation,
     TriccStatic, TriccReference, TriccNodeType, TriccEdge, OPERATION_LIST
@@ -107,7 +107,7 @@ def create_activity(diagram, media_path, project):
     if root is not None:
         activity = TriccNodeActivity(
             root=root,
-            name=name,  #  start node 'name' is saved in label
+            name=name,  # start node 'name' is saved in label
             id=id,
             external_id=external_id,
             label=label,

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/serializers/xls_form.py

@@ -16,7 +16,7 @@ from tricc_oo.models.calculate import (
     TriccNodeCalculate
 )
 from tricc_oo.models.tricc import (
-    TriccNodeActivity, TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
+    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
     TriccNodeSelectOne,
     TriccNodeSelect,
     TriccNodeMoreInfo,
@@ -39,7 +39,9 @@ logger = logging.getLogger("default")
 langs = SingletonLangClass()
 TRICC_CALC_EXPRESSION = "${{{0}}}>0"
 
-def get_export_group_name(in_node):return f"gcalc_{get_export_name(in_node)}"
+
+def get_export_group_name(in_node): return f"gcalc_{get_export_name(in_node)}"
+
 
 def start_group(
     strategy,
@@ -60,13 +62,12 @@ def start_group(
 
     else:
         groups[name] = 0
-    is_activity = isinstance(cur_group, TriccNodeActivity)
     relevance = relevance and cur_group.relevance is not None and cur_group.relevance != ""
     past_instances = len(getattr(cur_group.base_instance, "instances", []))
-    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances>1)
+    group_calc_required = relevance is not None and (len(str(relevance)) > 100 or past_instances > 1)
     calc = None
     if group_calc_required and getattr(cur_group.relevance, 'operator', None) != TriccOperator.ISTRUE:
-        
+
         calc = TriccNodeCalculate(
             id=generate_id(get_export_group_name(name)),
             group=cur_group,
@@ -77,23 +78,22 @@ def start_group(
         if calc not in cur_group.calculates:
             cur_group.calculates.append(calc)
             processed_nodes.add(calc)
-            
+
         cur_group.relevance = TriccOperation(
                 TriccOperator.ISTRUE,
                 [calc]
             )
-    
+
     relevance_expression = cur_group.relevance
     relevance_expression = get_applicability_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_prev_instance_skip_expression(cur_group, processed_nodes, process, relevance_expression)
     relevance_expression = get_process_skip_expression(cur_group, processed_nodes, process, relevance_expression)
 
-
     if not relevance:
         relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
         relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
-    
+
     # group
     values = []
     for column in SURVEY_MAP:
@@ -114,7 +114,7 @@ def start_group(
     df_survey.loc[len(df_survey)] = values
 
     # calc
-    if calc and len(df_calculate[df_calculate["name"] ==  get_export_group_name(name)]) == 0:
+    if calc and len(df_calculate[df_calculate["name"] == get_export_group_name(name)]) == 0:
         calc_values = []
         for column in SURVEY_MAP:
             if column == "type":

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/strategies/output/base_output_strategy.py

@@ -43,6 +43,9 @@ class BaseOutPutStrategy:
 
         self.export(self.project.start_pages, version=version)
 
+        logger.info("validate the output")
+        self.validate()
+
     # walking function
     def process_base(self, start_pages, **kwargs):
         # for each node, check if condition is required issubclass(TriccNodeDisplayModel)
@@ -106,6 +109,10 @@ class BaseOutPutStrategy:
     def export(self, **kwargs):
         pass
 
+    @abc.abstractmethod
+    def validate(self):
+        pass
+
     def tricc_operation_equal(self, ref_expressions):
         # r[0] = r[1]
         raise NotImplementedError("This type of opreration  is not supported in this strategy")

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/strategies/output/dhis2_form.py

@@ -145,15 +145,16 @@ class DHIS2Strategy(BaseOutPutStrategy):
             raise NotImplementedError(
                 f"This type of operation '{operation.operator}' is not supported in this strategy"
             )
+
     def get_display(self, node):
         if hasattr(node, 'label') and node.label:
-            ret =  node.label
+            ret = node.label
         elif hasattr(node, 'name') and node.name:
             ret = node.name
         else:
             ret = str(node.id)
-        return  ret.replace('\u00a0', ' ').strip()
-    
+        return ret.replace('\u00a0', ' ').strip()
+
     def execute(self):
         version = datetime.datetime.now().strftime("%Y%m%d%H%M")
         logger.info(f"build version: {version}")
@@ -273,13 +274,12 @@ class DHIS2Strategy(BaseOutPutStrategy):
                 "id": de_id,
                 "name": self.get_export_name(node),
                 "shortName": node.name[:50],
-                "displayFormName":self.get_display(node),
+                "displayFormName": self.get_display(node),
                 "formName": self.get_display(node),
                 "valueType": value_type,
                 "domainType": "TRACKER",
                 "aggregationType": "NONE"
             }
-            
             if issubclass(node.__class__, TriccNodeSelect) and not isinstance(node, TriccNodeSelectYesNo):
                 data_element["optionSetValue"] = True
 
@@ -736,15 +736,15 @@ class DHIS2Strategy(BaseOutPutStrategy):
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeCalculateBase):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeInputModel):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             # Use variable name from concept_map
-            node_id =  self.get_export_name(r)
+            node_id = self.get_export_name(r)
             return f"#{{{node_id}}}"
         else:
             raise NotImplementedError(f"This type of node {r.__class__.__name__} is not supported within an operation")

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/strategies/output/openmrs_form.py

@@ -410,7 +410,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         elif issubclass(r.__class__, TriccNodeInputModel):
             return self.get_export_name(r)
         elif issubclass(r.__class__, TriccNodeSelect):
-            return "(" + self.get_export_name(r) + " ?? [])"       
+            return "(" + self.get_export_name(r) + " ?? [])"
         elif issubclass(r.__class__, TriccNodeBaseModel):
             return self.get_export_name(r)
         else:
@@ -458,7 +458,7 @@ class OpenMRSStrategy(BaseOutPutStrategy):
         return f"!({ref_expressions[0]})"
 
     def tricc_operation_plus(self, ref_expressions):
-        return "(" + " + ".join(ref_expressions) +")" 
+        return "(" + " + ".join(ref_expressions) + ")"
 
     def tricc_operation_minus(self, ref_expressions):
         if len(ref_expressions) > 1:

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/strategies/output/xls_form.py

@@ -8,6 +8,7 @@ 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 (
@@ -409,7 +410,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return f"count-selected({self.clean_coalesce(ref_expressions[0])})"
 
     def tricc_operation_multiplied(self, ref_expressions):
-        return "*".join(map(str,ref_expressions))
+        return "*".join(map(str, ref_expressions))
 
     def tricc_operation_divided(self, ref_expressions):
         return f"{ref_expressions[0]} div {ref_expressions[1]}"
@@ -430,7 +431,7 @@ class XLSFormStrategy(BaseOutPutStrategy):
             return f"-{ref_expressions[0]}"
 
     def tricc_operation_plus(self, ref_expressions):
-        return " + ".join(map(str,ref_expressions))
+        return " + ".join(map(str, ref_expressions))
 
     def tricc_operation_not(self, ref_expressions):
         return f"not({ref_expressions[0]})"
@@ -474,7 +475,7 @@ 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):
         if str(BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]).isnumeric():
@@ -747,3 +748,33 @@ class XLSFormStrategy(BaseOutPutStrategy):
 
     def tricc_operation_concatenate(self, ref_expressions):
         return f"concat({','.join(map(str, ref_expressions))})"
+
+    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-1.6.6 → tricc_oo-1.6.8}/tricc_oo/strategies/output/xlsform_cht.py

@@ -2,6 +2,7 @@ import datetime
 import logging
 import os
 import shutil
+import subprocess
 import pandas as pd
 
 from tricc_oo.models.lang import SingletonLangClass
@@ -616,6 +617,9 @@ 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,
@@ -660,6 +664,7 @@ 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}",
@@ -708,6 +713,105 @@ 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")
+        self.validate(generated_files)
+
+    def validate(self, generated_files=None):
+        """Validate the generated XLS form(s) using xls2xform-medic."""
+        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 xls2xform-medic is available
+        medic_tool = self._ensure_xls2xform_medic()
+        if not medic_tool:
+            logger.error("xls2xform-medic tool 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:
+                # Run xls2xform-medic validation
+                result = subprocess.run(
+                    [medic_tool, xls_file],
+                    capture_output=True,
+                    text=True,
+                    cwd=self.output_path
+                )
+
+                if result.returncode == 0:
+                    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
+
+            except Exception as e:
+                logger.error(f"CHT XLSForm validation error for {os.path.basename(xls_file)}: {str(e)}")
+                all_valid = False
+
+        return all_valid
+
+    def _ensure_xls2xform_medic(self):
+        """Ensure xls2xform-medic tool is available."""
+        # Check if it's in PATH
+        medic_tool = shutil.which("xls2xform-medic")
+        if medic_tool:
+            return medic_tool
+
+        # Check if we need to download it
+        medic_path = os.path.join(os.path.dirname(__file__), "xls2xform-medic")
+        if os.path.exists(medic_path):
+            return medic_path
+
+        # Try to download from the provided URL
+        try:
+            import urllib.request
+            medic_url = "https://github.com/medic/pyxform/releases/download/v4.0.0-medic/xls2xform-medic"
+            logger.info(f"Downloading xls2xform-medic from {medic_url}")
+            urllib.request.urlretrieve(medic_url, medic_path)
+            # Make executable
+            os.chmod(medic_path, 0o755)
+            return medic_path
+        except Exception as e:
+            logger.error(f"Failed to download xls2xform-medic: {str(e)}")
+            return 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));

{tricc_oo-1.6.6 → tricc_oo-1.6.8}/tricc_oo/visitors/tricc.py

@@ -121,7 +121,10 @@ def get_last_version(name, processed_nodes, _list=None):
 # node is the node to calculate
 # processed_nodes are the list of processed nodes
 def get_node_expressions(node, processed_nodes, process=None):
-    get_overall_exp = issubclass(node.__class__, (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)) and not isinstance(node, (TriccNodeDisplayBridge))
+    get_overall_exp = issubclass(
+        node.__class__,
+        (TriccNodeDisplayCalculateBase, TriccNodeProposedDiagnosis, TriccNodeDiagnosis)
+    ) and not isinstance(node, (TriccNodeDisplayBridge))
     expression = None
     # in case of recursive call processed_nodes will be None
     if processed_nodes is None or is_ready_to_process(node, processed_nodes=processed_nodes):
@@ -173,8 +176,8 @@ def get_version_inheritance(node, last_version, processed_nodes):
                     node.relevance = expression
     else:
         node.last = False
-        
-                    # Create a calculate node that coalesces the previous saved value with the current node value
+
+        # Create a calculate node that coalesces the previous saved value with the current node value
         calc_id = generate_id(f"save_{node.save}")
         calc = TriccNodeCalculate(
             id=calc_id,
@@ -184,10 +187,10 @@ def get_version_inheritance(node, last_version, processed_nodes):
                 TriccOperator.COALESCE,
                 [TriccReference(node.save), last_version],
             ),
-            reference=[TriccReference(n.name)],
+            reference=[TriccReference(node.name)],
             activity=node.activity,
             group=node.group,
-            label=f"Save calculation for {n.label}",
+            label=f"Save calculation for {node.label}",
             last=True,
         )
         node.activity.nodes[calc.id] = calc
@@ -1765,7 +1768,10 @@ def reorder_node_list(node_list, group, processed_nodes):
         elif activity and isinstance(activity.root, TriccNodeActivityStart):
             priority += NON_START_ACTIVITY_PRIORITY
         # Check for display calculate and end nodes with prev_nodes
-        elif (issubclass(node.__class__, TriccNodeDisplayCalculateBase) or isinstance(node, TriccNodeEnd)) and not isinstance(node, TriccNodeActivityEnd) and hasattr(node, 'prev_nodes') and len(node.prev_nodes) > 0:
+        elif (
+            issubclass(node.__class__, TriccNodeDisplayCalculateBase) or
+            isinstance(node, TriccNodeEnd)
+        ) and not isinstance(node, TriccNodeActivityEnd) and hasattr(node, 'prev_nodes') and len(node.prev_nodes) > 0:
             priority += FLOW_CALCULATE_NODE_PRIORITY
         # Check for active activities (lower priority)
         elif activity and activity in active_activities:
@@ -2100,7 +2106,7 @@ def create_determine_diagnosis_activity(diags):
     )
     options = []
     for proposed in diags:
-        option =  TriccNodeSelectOption(
+        option = TriccNodeSelectOption(
             id=generate_id(proposed.name),
             name=proposed.name,
             label=proposed.label,
@@ -2108,6 +2114,7 @@ def create_determine_diagnosis_activity(diags):
             relevance=proposed.activity.applicability,
             select=f,
         )
+        options.append(option)
         d = get_accept_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity)
         c = get_diagnostic_node(proposed.name, proposed.label, proposed.severity, proposed.priority, activity, option)
         diags_conf.append(d)
@@ -2134,7 +2141,6 @@ def create_determine_diagnosis_activity(diags):
         activity.nodes[wait2.id] = wait2
     # fallback
 
-    
     f.options = dict(zip(range(0, len(options)), options))
     activity.nodes[f.id] = f
     set_prev_next_node(f, end, edge_only=False)
@@ -2307,7 +2313,11 @@ def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=
                 TriccOperator.CAST_NUMBER,
                 [
                     get_node_expression(
-                        prev_node, processed_nodes=processed_nodes, get_overall_exp=get_overall_exp, is_prev=True, process=process
+                        prev_node,
+                        processed_nodes=processed_nodes,
+                        get_overall_exp=get_overall_exp,
+                        is_prev=True,
+                        process=process
                     )
                 ],
             )

{tricc_oo-1.6.6 → tricc_oo-1.6.8/tricc_oo.egg-info}/PKG-INFO

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