tricc-oo 1.5.23__py3-none-any.whl → 1.5.25__py3-none-any.whl

tricc_oo/strategies/output/xls_form.py

@@ -12,24 +12,24 @@ import pandas as pd
 from tricc_oo.converters.utils import clean_name
 from tricc_oo.models.base import (
     TriccOperator,
-    TriccOperation, TriccStatic, TriccReference, TriccNodeType, or_join
+    TriccOperation, TriccStatic, TriccReference
 )
 from tricc_oo.models.ordered_set import OrderedSet
 from tricc_oo.models.calculate import (
     TriccNodeEnd,
     TriccNodeDisplayCalculateBase,
-    TriccRhombusMixIn,
 
 )
 from tricc_oo.models.tricc import (
     TriccNodeCalculateBase,
     TriccNodeBaseModel,
-    TriccNodeSelectMultiple,
     TriccNodeSelectOption,
     TriccNodeInputModel,
-    TriccNodeDisplayModel
+    TriccNodeDisplayModel,
+    TRICC_FALSE_VALUE,
+    TRICC_TRUE_VALUE,
 )
-from tricc_oo.converters.tricc_to_xls_form import get_export_name
+from tricc_oo.converters.tricc_to_xls_form import get_export_name, BOOLEAN_MAP
 
 from tricc_oo.models.lang import SingletonLangClass
 
@@ -39,9 +39,9 @@ from tricc_oo.visitors.tricc import (
     is_ready_to_process,
     process_reference,
     get_node_expressions,
-    TRICC_TRUE_VALUE,
-    TRICC_FALSE_VALUE,
     set_last_version_false,
+    generate_calculate,
+    generate_base,
 )
 from tricc_oo.serializers.xls_form import (
     CHOICE_MAP,
@@ -49,7 +49,6 @@ from tricc_oo.serializers.xls_form import (
     end_group,
     generate_xls_form_export,
     start_group,
-    BOOLEAN_MAP,
 )
 from tricc_oo.strategies.output.base_output_strategy import BaseOutPutStrategy
 
@@ -104,13 +103,13 @@ class XLSFormStrategy(BaseOutPutStrategy):
         return str(expression)
 
     def generate_base(self, node, **kwargs):
-        return self.generate_xls_form_condition(node, **kwargs)
+        return generate_base(node, **kwargs)
 
     def generate_relevance(self, node, **kwargs):
         return self.generate_xls_form_relevance(node, **kwargs)
 
     def generate_calculate(self, node, **kwargs):
-        return self.generate_xls_form_calculate(node, **kwargs)
+        return generate_calculate(node, **kwargs)
 
     def __init__(self, project, output_path):
         super().__init__(project, output_path)
@@ -131,6 +130,31 @@ class XLSFormStrategy(BaseOutPutStrategy):
     def generate_export(self, node, **kwargs):
         return generate_xls_form_export(self, node, **kwargs)
 
+    def inject_version(self):
+        # Add hidden version field using ODK's jr:version()
+        empty = langs.get_trads("", force_dict=True)
+        self.df_survey.loc[len(self.df_survey)] = [
+            "hidden",
+            "version",
+            *list(empty.values()),  # label
+            *list(empty.values()),  # hint
+            *list(empty.values()),  # help
+            "",  # default
+            "hidden",  # appearance
+            "",  # constraint
+            *list(empty.values()),  # constraint_message
+            "",  # relevance
+            "",  # disabled
+            "",  # required
+            *list(empty.values()),  # required_message
+            "",  # read only
+            "jr:version()",  # calculation
+            "",  # trigger
+            "",  # repeat_count
+            "",  # image
+            "",  # choice_filter
+        ]
+
     def export(self, start_pages, version):
         if start_pages["main"].root.form_id is not None:
             form_id = str(start_pages["main"].root.form_id)
@@ -158,10 +182,10 @@ class XLSFormStrategy(BaseOutPutStrategy):
         if not os.path.exists(self.output_path):
             os.makedirs(self.output_path)
 
+        self.inject_version()
+
         # create a Pandas Excel writer using XlsxWriter as the engine
         writer = pd.ExcelWriter(newpath, engine="xlsxwriter")
-        if len(self.df_survey[self.df_survey["name"] == "version"]):
-            self.df_survey.loc[self.df_survey["name"] == "version", "label"] = f"v{version}"
         self.df_survey.to_excel(writer, sheet_name="survey", index=False)
         self.df_choice.to_excel(writer, sheet_name="choices", index=False)
         df_settings.to_excel(writer, sheet_name="settings", index=False)
@@ -688,91 +712,30 @@ class XLSFormStrategy(BaseOutPutStrategy):
                 return True
         return False
 
-    # function update the select node in the XLSFORM format
-    # @param left part
-    # @param right part
-    def generate_xls_form_condition(self, node, processed_nodes, stashed_nodes, calculates, **kwargs):
-        if is_ready_to_process(node, processed_nodes, strict=False) and process_reference(
-            node,
-            processed_nodes,
-            calculates,
-            replace_reference=False,
-            codesystems=kwargs.get("codesystems", None),
-        ):
-            if node not in processed_nodes:
-                if issubclass(node.__class__, TriccRhombusMixIn) and isinstance(node.reference, str):
-                    logger.warning("node {} still using the reference string".format(node.get_name()))
-                if issubclass(node.__class__, TriccNodeInputModel):
-                    # we don't overright if define in the diagram
-                    if node.constraint is None:
-                        if isinstance(node, TriccNodeSelectMultiple):
-                            node.constraint = or_join(
-                                [
-                                    TriccOperation(
-                                        TriccOperator.EQUAL,
-                                        ["$this", TriccStatic("opt_none")],
-                                    ),
-                                    TriccOperation(
-                                        TriccOperator.NOT,
-                                        [
-                                            TriccOperation(
-                                                TriccOperator.SELECTED,
-                                                ["$this", TriccStatic("opt_none")],
-                                            )
-                                        ],
-                                    ),
-                                ]
-                            )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
-                            node.constraint_message = "**None** cannot be selected together with choice."
-                        elif node.tricc_type in (
-                            TriccNodeType.integer,
-                            TriccNodeType.decimal,
-                        ):
-                            constraints = []
-                            constraints_min = ""
-                            constraints_max = ""
-                            if node.min is not None and node.min != "":
-                                constraints.append(TriccOperation(TriccOperator.MORE_OR_EQUAL, ["$this", node.min]))
-                                constraints_min = "The minimun value is {0}.".format(node.min)
-                            if node.max is not None and node.max != "":
-                                constraints.append(TriccOperation(TriccOperator.LESS_OR_EQUAL, ["$this", node.max]))
-                                constraints_max = "The maximum value is {0}.".format(node.max)
-                            if len(constraints) > 1:
-                                node.constraint = TriccOperation(TriccOperator.AND, constraints)
-                                node.constraint_message = (constraints_min + " " + constraints_max).strip()
-                            elif len(constraints) == 1:
-                                node.constraint = constraints[0]
-                                node.constraint_message = (constraints_min + " " + constraints_max).strip()
-                # continue walk
-                return True
-        return False
-
-    # function transform an object to XLSFORM value
-    # @param r reference to be translated
     def get_tricc_operation_operand(self, r, coalesce_fallback="''"):
+        # function transform an object to XLSFORM value
+        # @param r reference to be translated
         if isinstance(r, TriccOperation):
             return self.get_tricc_operation_expression(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):
-            if isinstance(r.value, bool):  # or r.value in ('true', 'false')
-                return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)] if r.value else BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
-            if r.value == TRICC_TRUE_VALUE:
+            return get_export_name(r)
+        elif isinstance(r, str):
+            if r == TRICC_TRUE_VALUE:
                 return BOOLEAN_MAP[str(TRICC_TRUE_VALUE)]
-            if r.value == TRICC_FALSE_VALUE:
+            elif r == TRICC_FALSE_VALUE:
                 return BOOLEAN_MAP[str(TRICC_FALSE_VALUE)]
-            if isinstance(r.value, str):
-                return f"'{r.value}'"
+            elif isinstance(r, str):
+                return f"'{r}'"
             else:
-                return str(r.value)
-        elif isinstance(r, str):
-            return f"{r}"
+                return str(r)
         elif isinstance(r, (int, float)):
             return str(r)
         elif isinstance(r, TriccNodeSelectOption):
-            logger.warning(f"select option {r.get_name()} from {r.select.get_name()} was used as a reference")
-            return f"'{r.name}'"
+            logger.debug(f"select option {r.get_name()} from {r.select.get_name()} was used as a reference")
+            return get_export_name(r)
         elif issubclass(r.__class__, TriccNodeInputModel):
             return f"coalesce(${{{get_export_name(r)}}},{coalesce_fallback})"
         elif issubclass(r.__class__, TriccNodeBaseModel):

tricc_oo/strategies/output/xlsform_cht.py

@@ -31,6 +31,8 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
 
         self.df_survey = pd.concat([cht_input_df, self.df_survey, self.get_cht_summary()], ignore_index=True)
 
+        self.inject_version()
+
     def get_cht_input(self, start_pages, **kwargs):
         empty = langs.get_trads("", force_dict=True)
         df_input = pd.DataFrame(columns=SURVEY_MAP.keys())
@@ -620,8 +622,6 @@ class XLSFormCHTStrategy(XLSFormCDSSStrategy):
         }
         df_settings = pd.DataFrame(settings, index=indx)
         df_settings.head()
-        if len(self.df_survey[self.df_survey["name"] == "version"]):
-            self.df_survey.loc[self.df_survey["name"] == "version", "label"] = f"v{version}"
         # create a Pandas Excel writer using XlsxWriter as the engine
         writer = pd.ExcelWriter(newpath, engine="xlsxwriter")
         self.df_survey.to_excel(writer, sheet_name="survey", index=False)

tricc_oo/visitors/tricc.py

@@ -6,7 +6,7 @@ import base64
 
 from tricc_oo.converters.utils import generate_id
 from tricc_oo.models.base import (
-    TriccBaseModel,
+    TriccBaseModel, TriccNodeType,
     TriccOperator, TriccOperation, TriccStatic, TriccReference, not_clean,
     and_join, or_join, clean_or_list, nand_join, TriccEdge
 )
@@ -34,6 +34,7 @@ from tricc_oo.models.calculate import (
 from tricc_oo.models.tricc import (
     TriccNodeCalculateBase, TriccNodeActivity, TriccNodeBaseModel, TriccNodeNumber,
     TriccNodeSelectMultiple,
+    TriccNodeSelectOne,
     TriccNodeSelectOption,
     TriccNodeSelectYesNo,
     TriccNodeInputModel,
@@ -43,6 +44,8 @@ from tricc_oo.models.tricc import (
     TriccNodeDisplayModel,
     TriccNodeMainStart,
     TriccNodeAcceptDiagnostic,
+    TRICC_FALSE_VALUE,
+    TRICC_TRUE_VALUE,
 )
 from tricc_oo.visitors.utils import PROCESSES
 from tricc_oo.converters.cql_to_operation import transform_cql_to_operation
@@ -52,9 +55,6 @@ from tricc_oo.converters.tricc_to_xls_form import get_list_names, get_export_nam
 logger = logging.getLogger("default")
 ONE_QUESTION_AT_A_TIME = False
 
-TRICC_TRUE_VALUE = "true"
-TRICC_FALSE_VALUE = "false"
-
 
 def merge_node(from_node, to_node):
     if from_node.activity != to_node.activity:
@@ -217,7 +217,7 @@ def merge_expression(expression, last_version):
     return expression
 
 
-def process_calculate(
+def load_calculate(
     node, processed_nodes, stashed_nodes, calculates, used_calculates, warn=False, process=None, **kwargs
 ):
     # used_calculates dict[name, Dict[id, node]]
@@ -892,7 +892,7 @@ def add_used_calculate(node, prev_node, calculates, used_calculates, processed_n
                 used_calculates[prev_node.name][max_version.id] = max_version
         else:
             logger.debug(
-                "process_calculate_version_requirement: failed for {0} , prev Node {1} ".format(
+                "load_calculate_version_requirement: failed for {0} , prev Node {1} ".format(
                     node.get_name(), prev_node.get_name()
                 )
             )
@@ -2503,17 +2503,127 @@ def get_required_node_expression(node):
 
 # Get a selected option
 def get_selected_option_expression(option_node, negate):
+    if isinstance(option_node.select, TriccNodeSelectOne):
+        return get_selected_option_expression_single(option_node, negate)
+    else:
+        return get_selected_option_expression_multiple(option_node, negate)
+
+
+def get_selected_option_expression_single(option_node, negate):
+
+    if not negate:
+        return TriccOperation(TriccOperator.EQUAL, [option_node.select, option_node])
 
-    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, TriccStatic(option_node.name)])
+
+def get_selected_option_expression_multiple(option_node, negate):
+
+    selected = TriccOperation(TriccOperator.SELECTED, [option_node.select, option_node])
 
     if negate:
         return TriccOperation(
             operator=TriccOperator.AND,
             resource=[
                 TriccOperation(operator=TriccOperator.NOT, resource=[selected]),
-                TriccOperation(operator=TriccOperator.NATIVE, resource=["count-selected", option_node.select]),
+                TriccOperation(operator=TriccOperator.ISNOTNULL, resource=[option_node.select]),
             ],
         )
 
     else:
         return selected
+
+
+def generate_calculate(node, processed_nodes, **kwargs):
+    # For calculations, set calculate in questionOptions
+    # Check if node is ready to be processed (similar to XLS form strategy)
+    if not is_ready_to_process(node, processed_nodes, strict=True):
+        return False
+
+    # Process references to ensure dependencies are handled
+    if not process_reference(
+        node, processed_nodes, {}, replace_reference=True, codesystems=kwargs.get("codesystems", None)
+    ):
+        return False
+
+    if node not in processed_nodes:
+        if kwargs.get("warn", True):
+            logger.debug("generation of calculate for node {}".format(node.get_name()))
+        if (
+            hasattr(node, "expression")
+            and (node.expression is None)
+            and issubclass(node.__class__, TriccNodeCalculateBase)
+        ):
+            node.expression = get_node_expressions(
+                node, processed_nodes, process=kwargs.get("process", "main ")
+            )
+            # continue walk
+        if issubclass(
+            node.__class__,
+            (
+                TriccNodeDisplayModel,
+                TriccNodeDisplayCalculateBase,
+                TriccNodeEnd,
+            ),
+        ):
+            set_last_version_false(node, processed_nodes)
+    return True
+
+
+def generate_base(node, processed_nodes, **kwargs):
+    # Generate question for OpenMRS O3 schema
+    # Handle activity nodes by processing their inner content
+    # Check if node is ready to be processed (similar to XLS form strategy)
+    if not is_ready_to_process(node, processed_nodes, strict=False):
+        return False
+
+    # Process references to ensure dependencies are handled
+    if not process_reference(
+        node, processed_nodes, {}, replace_reference=False, codesystems=kwargs.get("codesystems", None)
+    ):
+        return False
+    if node not in processed_nodes:
+        if issubclass(node.__class__, TriccRhombusMixIn) and isinstance(node.reference, str):
+            logger.warning("node {} still using the reference string".format(node.get_name()))
+        if issubclass(node.__class__, TriccNodeInputModel):
+            # we don't overright if define in the diagram
+            if node.constraint is None:
+                if isinstance(node, TriccNodeSelectMultiple):
+                    node.constraint = or_join(
+                        [
+                            TriccOperation(
+                                TriccOperator.EQUAL,
+                                ["$this", TriccStatic("opt_none")],
+                            ),
+                            TriccOperation(
+                                TriccOperator.NOT,
+                                [
+                                    TriccOperation(
+                                        TriccOperator.SELECTED,
+                                        ["$this", TriccStatic("opt_none")],
+                                    )
+                                ],
+                            ),
+                        ]
+                    )  # '.=\'opt_none\' or not(selected(.,\'opt_none\'))'
+                    node.constraint_message = "**None** cannot be selected together with choice."
+                elif node.tricc_type in (
+                    TriccNodeType.integer,
+                    TriccNodeType.decimal,
+                ):
+                    constraints = []
+                    constraints_min = ""
+                    constraints_max = ""
+                    if node.min is not None and node.min != "":
+                        constraints.append(TriccOperation(TriccOperator.MORE_OR_EQUAL, ["$this", node.min]))
+                        constraints_min = "The minimun value is {0}.".format(node.min)
+                    if node.max is not None and node.max != "":
+                        constraints.append(TriccOperation(TriccOperator.LESS_OR_EQUAL, ["$this", node.max]))
+                        constraints_max = "The maximum value is {0}.".format(node.max)
+                    if len(constraints) > 1:
+                        node.constraint = TriccOperation(TriccOperator.AND, constraints)
+                        node.constraint_message = (constraints_min + " " + constraints_max).strip()
+                    elif len(constraints) == 1:
+                        node.constraint = constraints[0]
+                        node.constraint_message = (constraints_min + " " + constraints_max).strip()
+        # continue walk
+        return True
+    return False

{tricc_oo-1.5.23.dist-info → tricc_oo-1.5.25.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tricc-oo
-Version: 1.5.23
+Version: 1.5.25
 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
@@ -26,7 +26,130 @@ Requires-Dist: beautifulsoup4
 Requires-Dist: ocldev
 Dynamic: license-file
 
-# design  rules tricc_oo
+# TRICC-OO
+
+
+## Strategy
+
+### XLSFormStrategy
+
+to use on OKD and clones,
+
+### XLSFormCDSSStrategy
+
+based on XLSFormStrategy
+to use on OKD and clones, 
+support the CDSS specific behaviour such as Classification management
+
+### XLSFormCHTStrategy
+
+based on XLSFormCDSSStrategy
+to use on medic CHT if the questionnaire is run Patient level
+Support the inputs from patient
+Support the extention libs
+
+### XLSFormCHTHFStrategy
+
+based on XLSFormCHTStrategy
+to use on medic CHT if the questionnaire is run on Health facility level without selecting a patient
+Support inputs from HF
+
+
+### OpenMRSStrategy
+
+(under development)
+
+### FhirStrategy
+
+(UNTESTED)
+
+### HTMLStrategy
+
+(UNTESTED)
+
+## start nodes
+
+### Main start
+
+the flow required at least 1 main start node, but in case of cdss output strategy , several could be used given that they have a 'process' atrribute
+
+here is the list of the CPG process, this will be the execution oder too:
+- **registration**,
+- **triage**,
+- **emergency-care**,
+- **local-urgent-care**,
+- **actue-tertiary-care**,
+- **history-and-physical**,
+- **diagnostic-testing**,
+- **determine-diagnosis**,
+- **provide-counseling**,
+- **dispense-medications**,
+- **monitor-and-follow-up-of-patient**,
+- **alerts-reminders-education**,
+- **discharge-referral-of-patient**,
+- **charge-for-service**,
+- **record-and-report** 
+	
+	
+
+
+# Note
+
+## generation of the expressions 
+
+### add calcualte:
+
+ - Non or No in an egde will generate a negate node
+ - save adds a calcualte
+ - a rhombus will generate a calcualte using the reference (can you the label as a test, either with comparaisin or option selected with [option label])
+
+### for calculate 
+    
+Then we calculate based on the previous nodes: [get_prev_node_expression]
+    - if a "fake" calculate (Rhombus, exclusion) then get the underlying expression (should not depend of Calcualte = true) [get_calculation_terms]
+    - if a Select, manage it as a calculate too (should not depend of Calcualte = true) [get_calculation_terms]
+    - else get the expression via  [get_calculation_terms] [get_prev_node_expression , calculate = False] -> get_node_expression for the prev node
+
+# Running directly
+
+`tricc` is technically a python library, but you can run it directly via the [`build.py` script](./tests/build.py).
+
+## Running with Docker
+
+Alternatively, if you prefer to build/run the project with Docker, you can do the following.
+
+Start by building the Docker image:
+
+```shell
+git clone https://github.com/SwissTPH/tricc.git
+cd tricc
+
+docker build -t tricc .
+```
+
+Once you have the image built you can use it to convert local `.drawio` files by mapping the local directory to the `docker run` command. (Note that `--user` is specified to make sure the current host user has write access to the output files.)
+
+```shell
+docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc --help
+```
+
+This command will convert all `.drawio` files in the current directory:
+
+```shell
+docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj -o /proj
+```
+
+You can also convert a single file:
+
+```shell
+docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj/demo.drawio -o /proj
+```
+
+Use the `-O` flag to specify the output strategy. For example to generate CHT files:
+
+```shell
+docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj -o /proj -O XLSFormCHTStrategy
+```
 
 ## Nodes
 
@@ -133,90 +256,8 @@ if not a calculate then relevance will be used unless it is "required" then cond
 the Rhombus act as an AND between its imputs and its reference BUT it is an OR beween the inputs
 (input1 OR input2 OR input3) AND reference
 
-## start nodes
-
-### Main start
-
-the flow required at least 1 main start node, but in case of cdss output strategy , several could be used given that they have a 'process' atrribute
-
-here is the list of the CPG process, this will be the execution oder too:
-- **registration**,
-- **triage**,
-- **emergency-care**,
-- **local-urgent-care**,
-- **actue-tertiary-care**,
-- **history-and-physical**,
-- **diagnostic-testing**,
-- **determine-diagnosis**,
-- **provide-counseling**,
-- **dispense-medications**,
-- **monitor-and-follow-up-of-patient**,
-- **alerts-reminders-education**,
-- **discharge-referral-of-patient**,
-- **charge-for-service**,
-- **record-and-report** 
-	
-	
 # READ Xressource
 https://jgraph.github.io/drawio-tools/tools/convert.html
 
 option can have only incoming edge from images to be placed as option$
 
-
-# Note
-
-## generation of the expressions 
-
-### add calcualte:
-
- - Non or No in an egde will generate a negate node
- - save adds a calcualte
- - a rhombus will generate a calcualte using the reference (can you the label as a test, either with comparaisin or option selected with [option label])
-
-### for calculate 
-    
-Then we calculate based on the previous nodes: [get_prev_node_expression]
-    - if a "fake" calculate (Rhombus, exclusion) then get the underlying expression (should not depend of Calcualte = true) [get_calculation_terms]
-    - if a Select, manage it as a calculate too (should not depend of Calcualte = true) [get_calculation_terms]
-    - else get the expression via  [get_calculation_terms] [get_prev_node_expression , calculate = False] -> get_node_expression for the prev node
-
-# Running directly
-
-`tricc` is technically a python library, but you can run it directly via the [`build.py` script](./tests/build.py).
-
-## Running with Docker
-
-Alternatively, if you prefer to build/run the project with Docker, you can do the following.
-
-Start by building the Docker image:
-
-```shell
-git clone https://github.com/SwissTPH/tricc.git
-cd tricc
-
-docker build -t tricc .
-```
-
-Once you have the image built you can use it to convert local `.drawio` files by mapping the local directory to the `docker run` command. (Note that `--user` is specified to make sure the current host user has write access to the output files.)
-
-```shell
-docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc --help
-```
-
-This command will convert all `.drawio` files in the current directory:
-
-```shell
-docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj -o /proj
-```
-
-You can also convert a single file:
-
-```shell
-docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj/demo.drawio -o /proj
-```
-
-Use the `-O` flag to specify the output strategy. For example to generate CHT files:
-
-```shell
-docker run --rm -v "$PWD":/proj --user $(id -u):$(id -g) tricc -i /proj -o /proj -O XLSFormCHTStrategy
-```