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

tests/build.py

@@ -6,6 +6,7 @@ from tricc_oo.strategies.output.xls_form import XLSFormStrategy  # noqa: F401
 from tricc_oo.strategies.output.openmrs_form import OpenMRSStrategy  # noqa: F401
 from tricc_oo.strategies.output.fhir_form import FHIRStrategy  # noqa: F401
 from tricc_oo.strategies.output.html_form import HTMLStrategy  # noqa: F401
+from tricc_oo.strategies.output.dhis2_form import DHIS2Strategy  # noqa: F401
 from tricc_oo.strategies.input.drawio import DrawioStrategy  # noqa: F401
 import getopt
 import logging

tests/test_build.py

@@ -0,0 +1,260 @@
+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()

tricc_oo/converters/tricc_to_xls_form.py

@@ -1,6 +1,6 @@
 import logging
-from tricc_oo.converters.utils import clean_name, clean_str
-from tricc_oo.models.tricc import TriccNodeSelectOption, TRICC_TRUE_VALUE, TRICC_FALSE_VALUE
+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
 
@@ -43,6 +43,8 @@ def get_export_name(node, replace_dots=True):
             value = node.name
         elif isinstance(node, TriccStatic):
             value = node.value
+            if isinstance(value, TriccNodeSelectOption):
+                value = value.name
         else:
             value = node
         if isinstance(value, bool):  # or r.value in ('true', 'false')
@@ -51,10 +53,12 @@ def get_export_name(node, replace_dots=True):
             export_name = BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]
         elif value == TRICC_FALSE_VALUE:
             export_name = BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
-        elif isinstance(value, str):
-            export_name = f"'{clean_str(value, replace_dots=replace_dots)}'"
+        elif value == '$this':
+            export_name = '.'
+        elif isinstance(value, str) and not isinstance(node, str):
+            export_name = f"'{value}'"
         else:
-            export_name = str(value)
+            export_name = value
         if hasattr(node, 'export_name'):
             node.export_name = export_name
         return export_name
@@ -62,7 +66,12 @@ def get_export_name(node, replace_dots=True):
         return node
     else:
         node.gen_name()
-        if isinstance(node, TriccNodeSelectOption):
+        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(

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
@@ -101,16 +101,16 @@ def create_activity(diagram, media_path, project):
 
     external_id = diagram.attrib.get("id")
     id = get_id(external_id, diagram.attrib.get("id"))
-    root = create_root_node(diagram)
-    name = diagram.attrib.get("name")
+    root, name = create_root_node(diagram)
+    label = diagram.attrib.get("name")
     form_id = diagram.attrib.get("name", None)
     if root is not None:
         activity = TriccNodeActivity(
             root=root,
-            name=get_rand_name(f"a{id}"),
+            name=name,  # start node 'name' is saved in label
             id=id,
             external_id=external_id,
-            label=name,
+            label=label,
             form_id=form_id,
         )
         if root.relevance is not None:
@@ -130,7 +130,7 @@ def create_activity(diagram, media_path, project):
             if (
                 issubclass(n.__class__, (TriccNodeDisplayModel, TriccNodeDisplayCalculateBase))
                 and not isinstance(n, (TriccRhombusMixIn, TriccNodeRhombus, TriccNodeDisplayBridge))
-                and not n.name.startswith("label_")
+                and not n.name.startswith("label_")  # FIXME
             ):
                 system = n.name.split(".")[0] if "." in n.name else "tricc"
                 if isinstance(n, TriccNodeSelectOption) and isinstance(n.select, TriccNodeSelectNotAvailable):
@@ -444,17 +444,18 @@ def create_root_node(diagram):
         if elm is not None:
             external_id = elm.attrib.get("id")
             id = get_id(external_id, diagram.attrib.get("id"))
+            name = generate_id("start"+external_id)
             node = TriccNodeActivityStart(
                 id=id,
                 external_id=external_id,
                 # parent=elm.attrib.get("parent"),
-                name="ma" + id,
+                name=name,
                 label=diagram.attrib.get("name"),
                 relevance=elm.attrib.get("relevance"),
                 instance=int(elm.attrib.get("instance") if elm.attrib.get("instance") is not None else 1),
             )
     load_expressions(node)
-    return node
+    return node, _get_name(elm.attrib.get("name", "act_"), external_id, diagram.attrib.get("id")) if node else None
 
 
 # converter XML item to object

tricc_oo/models/base.py

@@ -11,7 +11,7 @@ from tricc_oo.models.ordered_set import OrderedSet
 
 logger = logging.getLogger("default")
 
-Expression = Annotated[str, StringConstraints(pattern=r"^[^\\/\:]+$")]
+Expression = Annotated[str, StringConstraints(pattern=r".+")]
 
 triccId = Annotated[str, StringConstraints(pattern=r"^[^\\/\: ]+$")]
 
@@ -274,7 +274,7 @@ class TriccNodeBaseModel(TriccBaseModel):
 
 
 class TriccStatic(BaseModel):
-    value: Union[str, float, int, bool]
+    value: Union[str, float, int, bool, TriccNodeBaseModel]
 
     def __init__(self, value):
         super().__init__(value=value)
@@ -494,6 +494,8 @@ class TriccOperation(BaseModel):
                 return "mixed"
             else:
                 return rtype.pop()
+        else:
+            return self.get_reference_datatype(self.reference)
 
     def get_reference_datatype(self, references):
         rtype = set()

tricc_oo/serializers/xls_form.py

@@ -6,16 +6,17 @@ from tricc_oo.converters.tricc_to_xls_form import (
     get_export_name, BOOLEAN_MAP
 )
 from tricc_oo.models.lang import SingletonLangClass
-from tricc_oo.converters.utils import clean_name, remove_html
+from tricc_oo.converters.utils import clean_name, remove_html, generate_id
 from tricc_oo.models.base import (
     TriccOperator,
     TriccOperation, TriccStatic, TriccReference, and_join, TriccNodeType
 )
 from tricc_oo.models.calculate import (
     TriccNodeDisplayCalculateBase,
+    TriccNodeCalculate
 )
 from tricc_oo.models.tricc import (
-    TriccNodeActivity, TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
+    TriccNodeBaseModel, TriccNodeSelectMultiple, TriccNodeSelectOption,
     TriccNodeSelectOne,
     TriccNodeSelect,
     TriccNodeMoreInfo,
@@ -39,6 +40,9 @@ langs = SingletonLangClass()
 TRICC_CALC_EXPRESSION = "${{{0}}}>0"
 
 
+def get_export_group_name(in_node): return f"gcalc_{get_export_name(in_node)}"
+
+
 def start_group(
     strategy,
     cur_group,
@@ -58,10 +62,27 @@ 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 != ""
-
-    group_calc_required = False and relevance and not is_activity and len(relevance) > 100
+    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)
+    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,
+            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)
+            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)
@@ -69,14 +90,9 @@ def start_group(
     relevance_expression = get_process_skip_expression(cur_group, processed_nodes, process, relevance_expression)
 
     if not relevance:
-        relevance_expression = ""
+        relevance_expression_str = ""
     elif isinstance(relevance_expression, (TriccOperation, TriccStatic)):
-        relevance_expression = strategy.get_tricc_operation_expression(relevance_expression)
-
-    # elif is_activity:
-    #    relevance_expression = TRICC_CALC_EXPRESSION.format(get_export_name(cur_group.root))
-    elif group_calc_required:
-        relevance_expression = TRICC_CALC_EXPRESSION.format("gcalc_" + name)
+        relevance_expression_str = strategy.get_tricc_operation_expression(relevance_expression)
 
     # group
     values = []
@@ -91,23 +107,23 @@ def start_group(
             if relevance_expression is True:
                 values.append("")
             else:
-                values.append(relevance_expression)
+                values.append(relevance_expression_str)
 
         else:
             values.append(get_xfrom_trad(strategy, cur_group, column, SURVEY_MAP))
     df_survey.loc[len(df_survey)] = values
 
     # calc
-    if group_calc_required and len(df_calculate[df_calculate["name"] == "gcalc_" + 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":
                 calc_values.append("calculate")
             elif column == "name":
-                value = "gcalc_" + name
+                value = get_export_name(calc)
                 calc_values.append(value)
             elif column == "calculation":
-                calc_values.append(get_attr_if_exists(strategy, cur_group, "relevance", SURVEY_MAP))
+                calc_values.append(f"number({strategy.get_tricc_operation_expression(calc.expression)}")
             elif column == "relevance":
                 calc_values.append("")
             else:
@@ -376,7 +392,7 @@ def get_attr_if_exists(strategy, node, column, map_array):
 
             elif isinstance(value, (TriccOperation, TriccStatic, TriccReference)):
                 expression = strategy.get_tricc_operation_expression(value)
-                return expression.replace("$this", ".") if isinstance(expression, str) else expression
+                return expression
             elif value is not None:
                 return str(value) if not isinstance(value, dict) else value
             else:
@@ -399,7 +415,7 @@ def get_more_info_select(strategy, node):
         if column == "type":
             values.append("select_one more_info")
         elif column == "label":
-            values.append("NO_LABEL")
+            values.append(strategy.get_empty_label())
         elif column == "name":
             values.append(get_export_name(node) + "_optin")
         elif column == "hint":

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")