tricc-oo 1.6.8__py3-none-any.whl → 1.6.14__py3-none-any.whl

tricc_oo/converters/codesystem_to_ocl.py

@@ -31,16 +31,16 @@ def extract_properties_metadata(fhir_cs: CodeSystem) -> Dict[str, Dict]:
 
             property_types[prop.code] = {
                 "name": prop.code,
-                "datatype": ocl_type,
+                "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"])
+    datatype = extract_concept_properties(concept, ["dataType"])
     if datatype:
-        return datatype["datatype"]
+        return datatype["dataType"]
     else:
         return OclConstants.DATA_TYPE_NONE
 
@@ -84,7 +84,7 @@ def get_attributes_from_concept_properties(concept, property_types: Dict) -> Lis
                 "type": "Attribute",
                 "attribute_type": code,
                 "value": value,
-                "value_type": property_types[code]["datatype"],
+                "value_type": property_types[code]["dataType"],
             }
         )
     return attributes

tricc_oo/converters/datadictionnary.py

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

tricc_oo/converters/drawio_type_map.py

@@ -47,7 +47,7 @@ TYPE_MAP = {
     },
     TriccNodeType.note: {
         "objects": ["UserObject", "object"],
-        "attributes": ["relevance", "priority", "context_type"],
+        "attributes": ["relevance", "priority", "concept_type"],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeNote,
     },
@@ -76,7 +76,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectOne,
@@ -94,7 +94,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectMultiple,
@@ -112,7 +112,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDecimal,
@@ -130,7 +130,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeInteger,
@@ -145,7 +145,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeText,
@@ -160,7 +160,7 @@ TYPE_MAP = {
             "default",
             "constraint",
             "constraint_message",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name"],
         "model": TriccNodeDate,
@@ -183,7 +183,7 @@ TYPE_MAP = {
             "save",
             "reference",
             "trigger",
-            "context_type",
+            "concept_type",
             "remote_reference",
         ],
         "mandatory_attributes": ["name", "label"],
@@ -217,7 +217,7 @@ TYPE_MAP = {
     },
     TriccNodeType.not_available: {
         "objects": ["UserObject", "object"],
-        "attributes": ["context_type"],
+        "attributes": ["concept_type"],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectNotAvailable,
     },
@@ -233,7 +233,7 @@ TYPE_MAP = {
             "priority",
             "trigger",
             "default",
-            "context_type",
+            "concept_type",
         ],
         "mandatory_attributes": ["label", "name", "list_name"],
         "model": TriccNodeSelectYesNo,
@@ -295,7 +295,7 @@ TYPE_MAP = {
     },
     TriccNodeType.input: {
         "objects": ["UserObject", "object"],
-        "attributes": ["save", "reference", "datatype", "context_type"],
+        "attributes": ["save", "reference", "data_type", "concept_type"],
         "mandatory_attributes": ["name", "label"],
         "model": TriccNodeInput,
     },

tricc_oo/converters/tricc_to_xls_form.py

@@ -36,7 +36,7 @@ def get_export_name(node, replace_dots=True):
     elif isinstance(node, bool):
         return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)] if node else BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
     elif isinstance(node, TriccReference):
-        logger.warning(f"Reference {node.value} use in export, bad serialiuation probable")
+        logger.warning(f"Reference {node.value} use in export, bad serialization probable")
         return str(node.value)
     elif isinstance(node, (str, TriccStatic, TriccNodeSelectOption)):
         if isinstance(node, TriccNodeSelectOption):

tricc_oo/converters/xml_to_tricc.py

@@ -128,7 +128,7 @@ def create_activity(diagram, media_path, project):
         for n in nodes.values():
 
             if (
-                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase))
+                issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase, TriccNodeInput))
                 and not isinstance(n, (TriccRhombusMixIn, TriccNodeRhombus, TriccNodeDisplayBridge))
                 and not n.name.startswith("label_")  # FIXME
             ):
@@ -139,7 +139,7 @@ def create_activity(diagram, media_path, project):
                         system,
                         n.select.name,
                         n.label,
-                        {"datatype": "Boolean", "contextType": get_context_type(n)},
+                        {"dataType": "Boolean", "conceptType": get_concept_type(n)},
                     )
                 elif not isinstance(n, TriccNodeSelectNotAvailable):
                     add_concept(
@@ -148,8 +148,20 @@ def create_activity(diagram, media_path, project):
                         n.name,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
+                        },
+                    )
+                elif not issubclass(n.__class__, TriccNodeCalculate):
+                    system = n.name.split(".")[0] if "." in n.name else "calculate"
+                    add_concept(
+                        project.code_systems,
+                        system,
+                        n.name,
+                        n.label,
+                        {
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
                 if getattr(n, "save", None):
@@ -160,8 +172,8 @@ def create_activity(diagram, media_path, project):
                         n.save,
                         n.label,
                         {
-                            "datatype": get_data_type(n.tricc_type),
-                            "contextType": get_context_type(n),
+                            "dataType": get_data_type(n.tricc_type),
+                            "conceptType": get_concept_type(n),
                         },
                     )
 
@@ -175,7 +187,7 @@ def create_activity(diagram, media_path, project):
         # link back the activity
         activity.root.activity = activity
         manage_dangling_calculate(activity)
-
+        # assign the process
         if activity is not None:
             if activity.root is not None:
                 project.pages[activity.id] = activity
@@ -197,6 +209,7 @@ def create_activity(diagram, media_path, project):
                         )
         if images:
             project.images += images
+        # Assign parent to NotAvailable
         for node in list(
             filter(
                 lambda p_node: isinstance(p_node, TriccNodeSelectNotAvailable),
@@ -477,10 +490,10 @@ def set_additional_attributes(attribute_names, elm, node):
             setattr(node, attributename, attribute)
 
 
-def get_context_type(node):
-    context_type = getattr(node, "context_type", None)
-    if context_type:
-        return context_type
+def get_concept_type(node):
+    concept_type = getattr(node, "concept_type", None)
+    if concept_type:
+        return concept_type
     if isinstance(node, TriccNodeSelectMultiple):
         return "Question"
     elif isinstance(node, TriccNodeSelectOption):
@@ -535,7 +548,7 @@ def get_select_options(diagram, select_node, nodes):
             activity=select_node.activity,
             group=select_node.group,
         )
-        set_additional_attributes(["save", "relevance", "context_type"], elm, option)
+        set_additional_attributes(["save", "relevance", "concept_type"], elm, option)
         load_expressions(option)
         options[i] = option
         nodes[id] = option
@@ -625,6 +638,8 @@ def enrich_node(diagram, media_path, edge, node, activity, help_before=False):
                     name=f"{node.name}.more_info",
                     label=message,
                     parent=node,
+                    group=node.group,
+                    activity=node.activity,
                     required=None,
                 )
                 # node.help = message
@@ -800,9 +815,11 @@ def set_mandatory_attribute(elm, mandatory_attributes, diagram=None):
             id = elm.attrib.get("id")
             attribute_value = _get_name(name, id, diagram_id)
         elif attributes == "list_name":
-            name = elm.attrib.get("name")
-            id = elm.attrib.get("id")
-            attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
+            attribute_value = elm.attrib.get("list_name", None)
+            if not attribute_value:
+                name = elm.attrib.get("name")
+                id = elm.attrib.get("id")
+                attribute_value = TRICC_LIST_NAME.format(clean_str(_get_name(name, id, diagram_id), replace_dots=True))
         else:
             attribute_value = elm.attrib.get(attributes)
         if attribute_value is None:

tricc_oo/serializers/xls_form.py

@@ -32,6 +32,7 @@ from tricc_oo.visitors.tricc import (
     get_applicability_expression,
     get_prev_instance_skip_expression,
     get_process_skip_expression,
+    process_operation_reference,
 )
 
 logger = logging.getLogger("default")
@@ -70,13 +71,24 @@ def start_group(
 
         calc = TriccNodeCalculate(
             id=generate_id(get_export_group_name(name)),
-            group=cur_group,
+            group=cur_group.group,
             activity=cur_group.activity,
             name=get_export_group_name(name),
             expression=cur_group.relevance
         )
-        if calc not in cur_group.calculates:
-            cur_group.calculates.append(calc)
+
+        if calc not in cur_group.activity.calculates:
+            process_reference(
+                calc,
+                processed_nodes,
+                calculates=kwargs.get('calculates', None),
+                used_calculates=kwargs.get('used_calculates', None),
+                replace_reference=True,
+                warn=False,
+                codesystems=kwargs.get('codesystems', None)
+            )
+            cur_group.activity.calculates.append(calc)
+            cur_group.activity.nodes[calc.id] = calc
             processed_nodes.add(calc)
 
         cur_group.relevance = TriccOperation(
@@ -92,7 +104,18 @@ def start_group(
     if not relevance:
         relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
-        relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
+        relevance_expression = process_operation_reference(
+            relevance_expression,
+            cur_group,
+            processed_nodes=processed_nodes,
+            calculates=kwargs.get('calculates', None),
+            used_calculates=kwargs.get('used_calculates', None),
+            replace_reference=True,
+            warn=False,
+            codesystems=kwargs.get('codesystems', None),
+        ) or relevance_expression
+        if relevance_expression:
+            relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
 
     # group
     values = []
@@ -123,7 +146,7 @@ def start_group(
                 value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(f"number({strategy.get_tricc_operation_expression(calc.expression)}")
+                calc_values.append(f"number({strategy.get_tricc_operation_expression(calc.expression)})")
             elif column == "relevance":
                 calc_values.append("")
             else:

tricc_oo/strategies/output/xlsform_cht.py

@@ -3,8 +3,12 @@ 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
@@ -740,10 +744,12 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         generated_files = self.export(self.project.start_pages, version=version)
 
         logger.info("validate the output")
-        self.validate(generated_files)
+        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 xls2xform-medic."""
+        """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:
@@ -753,10 +759,10 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 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")
+        # 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
@@ -767,49 +773,70 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
                 continue
 
             try:
-                # Run xls2xform-medic validation
-                result = subprocess.run(
-                    [medic_tool, xls_file],
-                    capture_output=True,
-                    text=True,
-                    cwd=self.output_path
+                # 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:
-                    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
+                    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
 
-        return all_valid
+                jar_in_zip = "site-packages/pyxform/validators/odk_validate/bin/ODK_Validate.jar"
+                zip_ref.extract(jar_in_zip, os.path.dirname(__file__))
+
+                # Move to final location
+                extracted_jar = os.path.join(os.path.dirname(__file__), jar_in_zip)
+                shutil.move(extracted_jar, jar_path)
+
+            logger.info(f"Extracted ODK Validate JAR to {jar_path}")
+            return jar_path
 
-    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
+    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 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
+        # Check if JAR already exists
+        if os.path.exists(jar_path):
+            return jar_path
 
-        # Try to download from the provided URL
+        # 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
-            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
+            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 xls2xform-medic: {str(e)}")
+            logger.error(f"Failed to download ODK Validate JAR: {str(e)}")
             return None
 
     def tricc_operation_zscore(self, ref_expressions):
@@ -836,7 +863,7 @@ 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):
         # drug name

tricc_oo/visitors/tricc.py

@@ -185,9 +185,9 @@ def get_version_inheritance(node, last_version, processed_nodes):
             path_len=node.path_len + 1,
             expression_reference=TriccOperation(
                 TriccOperator.COALESCE,
-                [TriccReference(node.save), last_version],
+                [node, last_version],
             ),
-            reference=[TriccReference(node.name)],
+            reference=[node, last_version],
             activity=node.activity,
             group=node.group,
             label=f"Save calculation for {node.label}",
@@ -805,7 +805,7 @@ def process_operation_reference(
     operation,
     node,
     processed_nodes,
-    calculates,
+    calculates=None,
     used_calculates=None,
     replace_reference=False,
     warn=False,
@@ -1735,29 +1735,33 @@ def replace_next_node(prev_node, next_node, old_node):
 
 
 # Priority constants
-SAME_GROUP_PRIORITY = 7000
-PARENT_GROUP_PRIORITY = 6000
-ACTIVE_ACTIVITY_PRIORITY = 5000
-NON_START_ACTIVITY_PRIORITY = 4000
-ACTIVE_ACTIVITY_LOWER_PRIORITY = 3000
-FLOW_CALCULATE_NODE_PRIORITY = 6500
-RHOMBUS_PRIORITY = 1000
-DEFAULT_PRIORITY = 2000
-
-
+SAME_GROUP_PRIORITY = 70
+PARENT_GROUP_PRIORITY = 60
+ACTIVE_ACTIVITY_PRIORITY = 50
+NON_START_ACTIVITY_PRIORITY = 40
+ACTIVE_ACTIVITY_LOWER_PRIORITY = 30
+FLOW_CALCULATE_NODE_PRIORITY_TOP_UP = 3
+RHOMBUS_PRIORITY_TO_UP = 3
+
+    
 def reorder_node_list(node_list, group, processed_nodes):
     # Cache active activities for O(1) lookup
     active_activities = {n.activity for n in processed_nodes}
-
+    MAP_PRIORITIES = {}
     def get_priority(node):
+        if node.id in MAP_PRIORITIES:
+            return MAP_PRIORITIES[node.id]
+        if isinstance(node, (TriccNodeActivityStart, TriccNodeMainStart)):
+            return get_priority(node.activity)
+
         # Cache attributes to avoid repeated getattr calls
-        priority = int(getattr(node, "priority", 0) or 0)
+        priority = int(getattr(node, "priority", 0) or 0) 
         node_group = getattr(node, "group", None)
         activity = getattr(node, "activity", None)
 
         # Check for same group
         if group is not None and node_group and node_group.id == group.id:
-            priority += SAME_GROUP_PRIORITY
+            priority += SAME_GROUP_PRIORITY 
         # Check for parent group
         elif hasattr(group, "group") and group.group and node_group and node_group.id == group.group.id:
             priority += PARENT_GROUP_PRIORITY
@@ -1767,21 +1771,25 @@ def reorder_node_list(node_list, group, processed_nodes):
         # Check for non main activities
         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:
-            priority += FLOW_CALCULATE_NODE_PRIORITY
         # Check for active activities (lower priority)
         elif activity and activity in active_activities:
             priority += ACTIVE_ACTIVITY_LOWER_PRIORITY
         # Check for rhombus nodes
+        
+
+        if (
+            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_TOP_UP
         elif issubclass(node.__class__, TriccRhombusMixIn):
-            priority += RHOMBUS_PRIORITY
-        else:
-            priority += DEFAULT_PRIORITY
+            priority += RHOMBUS_PRIORITY_TO_UP
 
+        if node.prev_nodes:
+            priority = max(priority, *[get_priority(p) for p in node.prev_nodes])
+        
+        MAP_PRIORITIES[node.id] = priority
+        
         return priority
 
     # Sort in place, highest priority first
@@ -1977,7 +1985,7 @@ def get_prev_instance_skip_expression(node, processed_nodes, process, expression
 
 # end def
 def get_process_skip_expression(node, processed_nodes, process, expression=None):
-    list_ends = OrderedSet(filter(lambda x: issubclass(x.__class__, TriccNodeEnd), processed_nodes))
+    list_ends = [x for x in processed_nodes if isinstance(x, TriccNodeEnd)]
     if list_ends:
         end_expressions = []
         f_end_expression = get_end_expression(list_ends)
@@ -1986,8 +1994,11 @@ def get_process_skip_expression(node, processed_nodes, process, expression=None)
         b_end_expression = get_end_expression(list_ends, "pause")
         if b_end_expression:
             end_expressions.append(b_end_expression)
-        if process[0] in PROCESSES:
-            for p in PROCESSES[PROCESSES.index(process[0]) + 1:]:
+        process_index = None
+        if process and process[0] in PROCESSES:
+            process_index = PROCESSES.index(process[0])
+        if process_index is not None:
+            for p in PROCESSES[process_index + 1:]:
                 p_end_expression = get_end_expression(list_ends, p)
                 if p_end_expression:
                     end_expressions.append(p_end_expression)
@@ -2259,7 +2270,12 @@ def get_none_option(node):
 def get_count_terms_details(prev_node, processed_nodes, get_overall_exp, negate=False, process=None):
     opt_none = get_none_option(prev_node)
     if opt_none:
-        operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(opt_none)])
+        if isinstance(opt_none, str):
+            operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic(opt_none)])
+        elif issubclass(opt_none.__class__, TriccBaseModel):
+            operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, opt_none])
+        else:
+            logger.critical(f"unexpected none option value {opt_none}")
     else:
         operation_none = TriccOperation(TriccOperator.SELECTED, [prev_node, TriccStatic("opt_none")])
     if isinstance(prev_node, TriccNodeSelectYesNo):

{tricc_oo-1.6.8.dist-info → tricc_oo-1.6.14.dist-info}/METADATA

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

@@ -1,16 +1,15 @@
 tests/build.py,sha256=Qbxvjkj_Wk2nQ-WjaMGiE1FIe3SRmJMRIgeoMoxqlfQ,6748
-tests/test_build.py,sha256=5t8iliPe_0XwoZjSGkHxUbZaNOWBfc6SpIQijh9DLUA,10037
 tests/test_cql.py,sha256=dAsLMqVaS6qxnq62fg5KqTFu6UG6pHO6Ab3NZ1c9T3Y,5248
 tests/to_ocl.py,sha256=4e-i65K3UM6wHgdVcrZcM9AyL1bahIsXJiZTXhhHgQk,2048
 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=Fh7Vk73OsxljZKu1k6H9uzYwz334tpQTMZBjWWbamYE,6151
+tricc_oo/converters/codesystem_to_ocl.py,sha256=V_oZNVUVaYHgzJtDiBMSrvIJnBWmDNFBDTTHEkOfpXk,6151
 tricc_oo/converters/cql_to_operation.py,sha256=PUyV_YpUY98Ox0H_F_CN3UUf_I-BhFZVOcWWKTtwecM,14492
-tricc_oo/converters/datadictionnary.py,sha256=T2HLCBo4Am1p0kFqSH1r0PqbD8AC2IGuWkbvMvSCru0,3658
-tricc_oo/converters/drawio_type_map.py,sha256=UCPiGs7Lw0bigKScmZUnmOhACBz-FiDq92jHkI7RTSQ,9113
-tricc_oo/converters/tricc_to_xls_form.py,sha256=wsWv4aA0QssY7ry9R7KsuuMzVfovj9fwE3i9AtCum0c,3842
+tricc_oo/converters/datadictionnary.py,sha256=JasqlLKiZzKdidsA1xc2SJ_Af1Xr6A3sKfzDynto8Ho,3686
+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
-tricc_oo/converters/xml_to_tricc.py,sha256=PEBe8N-JIGJMVX2FO3UVxRcy5GrGsMvgcArEwUXmr6o,39572
+tricc_oo/converters/xml_to_tricc.py,sha256=ea8LNEPDe32q74AJCbEjxaLt_Po47oH45K_G8fo7TzE,40388
 tricc_oo/converters/cql/cqlLexer.py,sha256=8HArbRphcrpnAG4uogJ2rHv4tc1WLzjN0B1uFeYILAc,49141
 tricc_oo/converters/cql/cqlListener.py,sha256=fA7-8DcS2Q69ckwjdg57-OfFHBxjTZFdoSKrtw7Hffc,57538
 tricc_oo/converters/cql/cqlParser.py,sha256=x3KdrwX9nwENSEJ5Ex7_l5NMnu3kWBO0uLdYu4moTq0,414745
@@ -26,7 +25,7 @@ tricc_oo/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 tricc_oo/parsers/xml.py,sha256=uzkb1y18MHfqVFmZqVh0sKT4cx6u0-NcAT_lV_gHBt8,4208
 tricc_oo/serializers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/serializers/planuml.py,sha256=t57587-6L3aDncpHh58lS77Zft8yxDE9DPtXx2BeUSU,132
-tricc_oo/serializers/xls_form.py,sha256=L0WF774zFt6PbdqncJGeyZzM9NiLq9NY5vO98yGTLhM,22133
+tricc_oo/serializers/xls_form.py,sha256=ydaD5l_CsMEhJlSO0XvXPdxrwsDw4HiRjTOPHogTQdw,23071
 tricc_oo/strategies/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tricc_oo/strategies/input/base_input_strategy.py,sha256=BEODXS74na1QRRcJVQ4cxiD8F7uRqaLyhE3QzKpGVvk,3891
@@ -39,14 +38,14 @@ tricc_oo/strategies/output/openmrs_form.py,sha256=ne6TwAyhafR-WDs27QTKKFl85VD5si
 tricc_oo/strategies/output/spice.py,sha256=QMeoismVC3PdbvwTK0PtUjWX9jl9780fbQIXn76fMXw,10761
 tricc_oo/strategies/output/xls_form.py,sha256=_pNTND7n-55EjRphJ1hSVtRYa-UkXlmwpam2OKQ8o_w,30860
 tricc_oo/strategies/output/xlsform_cdss.py,sha256=X00Lt5MzV8TX14dR4dFI1MqllI5S1e13bKbeysWM9uA,17435
-tricc_oo/strategies/output/xlsform_cht.py,sha256=eKAc6LLDnvdZ5m8a2Vk6eAhvPbUvOfykgYr0ou3an9k,27164
+tricc_oo/strategies/output/xlsform_cht.py,sha256=Zy8aggR1sTBP0b33RGbfUpk8pRppI1LGQEif4E1l49A,28523
 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=8fULbAxKSeEtPyD5TYTaIG8-20Bjg2iZmzxcJM70n18,110295
+tricc_oo/visitors/tricc.py,sha256=QkVZpmDvSrMbMQeCxVn15zSk3iH-3-e-udMys96JkXE,110923
 tricc_oo/visitors/utils.py,sha256=j83aAq5s5atXi3OC0jc_uJd54a8XrHHmizeeEbWZQJg,421
 tricc_oo/visitors/xform_pd.py,sha256=ryAnI3V9x3eTmJ2LNsUZfvl0_yfCqo6oBgeSu-WPqaE,9613
-tricc_oo-1.6.8.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
-tricc_oo-1.6.8.dist-info/METADATA,sha256=g9u0_NdvNT8FFgNB3LQzsUADmGqL1PBB1DPdnCBKVuI,8599
-tricc_oo-1.6.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tricc_oo-1.6.8.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
-tricc_oo-1.6.8.dist-info/RECORD,,
+tricc_oo-1.6.14.dist-info/licenses/LICENSE,sha256=Pz2eACSxkhsGfW9_iN60pgy-enjnbGTj8df8O3ebnQQ,16726
+tricc_oo-1.6.14.dist-info/METADATA,sha256=_WkaLTsN1Yj8koCLVrOmdY9egk06du90gsMqRCcQ0Js,8600
+tricc_oo-1.6.14.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tricc_oo-1.6.14.dist-info/top_level.txt,sha256=NvbfMNAiy9m4b1unBsqpeOQWh4IgA1Xa33BtKA4abxk,15
+tricc_oo-1.6.14.dist-info/RECORD,,

tests/test_build.py

@@ -1,260 +0,0 @@
-import unittest
-import subprocess
-import sys
-import os
-import tempfile
-import shutil
-from pathlib import Path
-import pandas as pd
-from pyxform import create_survey_from_xls
-
-
-class TestBuildScript(unittest.TestCase):
-    """Test cases for the build.py script with different argument combinations."""
-
-    def setUp(self):
-        """Set up test fixtures."""
-        self.test_data_dir = Path(__file__).parent / "data"
-        self.test_output_dir = Path(__file__).parent / "output"
-        self.demo_file = self.test_data_dir / "demo.drawio"
-
-        # Ensure test data exists
-        self.assertTrue(self.demo_file.exists(), f"Test data file {self.demo_file} does not exist")
-
-    def run_build_script(self, args):
-        """Helper method to run build.py with given arguments."""
-        cmd = [sys.executable, str(Path(__file__).parent / "build.py")] + args
-        result = subprocess.run(cmd, capture_output=True, text=True, cwd=Path(__file__).parent.parent)
-        return result
-
-    def test_basic_build_with_demo_file(self):
-        """Test basic build with demo.drawio file."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_directory_input(self):
-        """Test build with directory containing drawio files."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.test_data_dir),
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_xlsform_strategy(self):
-        """Test build with XLSFormStrategy (default)."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_html_strategy(self):
-        """Test build with HTMLStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "HTMLStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_fhir_strategy(self):
-        """Test build with FHIRStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "FHIRStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_dhis2_strategy(self):
-        """Test build with DHIS2Strategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "DHIS2Strategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_openmrs_strategy(self):
-        """Test build with OpenMRSStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "OpenMRSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cht_strategy(self):
-        """Test build with XLSFormCHTStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCHTStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cht_hf_strategy(self):
-        """Test build with XLSFormCHTHFStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCHTHFStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_cdss_strategy(self):
-        """Test build with XLSFormCDSSStrategy."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCDSSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    # def test_build_with_spice_strategy(self):
-    #     """Test build with SpiceStrategy."""
-    #     with tempfile.TemporaryDirectory() as temp_dir:
-    #         args = [
-    #             "-i", str(self.demo_file),
-    #             "-o", temp_dir,
-    #             "-O", "SpiceStrategy",
-    #             "-l", "i"
-    #         ]
-    #         result = self.run_build_script(args)
-    #         self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_debug_level(self):
-        """Test build with debug logging level."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-l", "d"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_trad_option(self):
-        """Test build with translation option."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-t",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_with_form_id(self):
-        """Test build with custom form ID."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-d", "test_form_123",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-    def test_build_missing_input(self):
-        """Test build with missing input file."""
-        args = ["-o", "/tmp/test_output"]
-        result = self.run_build_script(args)
-        self.assertNotEqual(result.returncode, 0, "Build should fail with missing input")
-
-    def test_build_invalid_input_file(self):
-        """Test build with invalid input file."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            args = [
-                "-i", "/nonexistent/file.drawio",
-                "-o", temp_dir,
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertNotEqual(result.returncode, 0, "Build should fail with invalid input file")
-
-    def validate_xls_form(self, xls_path):
-        """Helper method to validate XLS form using ODK libraries."""
-        try:
-            # Convert XLS to XML using pyxform
-            survey = create_survey_from_xls(xls_path)
-            xml_output = survey.to_xml()
-
-            # Basic validation - check if XML was generated successfully
-            # In a real scenario, you might want to use odk_validate command line tool
-            if xml_output and len(xml_output.strip()) > 0:
-                return True, "Validation successful"
-            else:
-                return False, "Empty XML output"
-        except Exception as e:
-            return False, str(e)
-
-    def test_xlsform_strategy_validation(self):
-        """Test XLSFormStrategy output validation with ODK libraries."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-            # Check if XLS file was created
-            self.assertTrue(xls_output.exists(), f"XLS file {xls_output} was not created")
-
-    def test_xlsform_cdss_strategy_validation(self):
-        """Test XLSFormCDSSStrategy output validation with ODK libraries."""
-        with tempfile.TemporaryDirectory() as temp_dir:
-            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
-            args = [
-                "-i", str(self.demo_file),
-                "-o", temp_dir,
-                "-O", "XLSFormCDSSStrategy",
-                "-l", "i"
-            ]
-            result = self.run_build_script(args)
-            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
-
-
-
-if __name__ == "__main__":
-    unittest.main()