#1274: Add inline compared syntax for N-way set-based output variable comparison

cdisc_rules_engine/models/actions.py

@@ -10,6 +10,7 @@
     SOURCE_ROW_NUMBER,
 )
 from cdisc_rules_engine.enums.sensitivity import Sensitivity
+from cdisc_rules_engine.enums.rule_types import RuleTypes
 from cdisc_rules_engine.models.sdtm_dataset_metadata import SDTMDatasetMetadata
 from cdisc_rules_engine.models.dataset_variable import DatasetVariable
 from cdisc_rules_engine.models.validation_error_container import (
@@ -89,6 +90,21 @@ def _get_target_names_from_list_values(
                         existing.add(value)
         return expanded
 
+    def _get_missing_variable_message(self) -> str:
+        """Get appropriate message for missing variables based on rule type."""
+        rule_type = self.rule.get("rule_type", "")
+        metadata_check_types = [
+            RuleTypes.VARIABLE_METADATA_CHECK.value,
+            RuleTypes.VARIABLE_METADATA_CHECK_AGAINST_DEFINE.value,
+            RuleTypes.VARIABLE_METADATA_CHECK_AGAINST_DEFINE_XML_AND_LIBRARY.value,
+            RuleTypes.VARIABLE_METADATA_CHECK_AGAINST_LIBRARY.value,
+            RuleTypes.DATASET_METADATA_CHECK.value,
+            RuleTypes.DATASET_METADATA_CHECK_AGAINST_DEFINE.value,
+        ]
+        if rule_type in metadata_check_types:
+            return "not available in metadata context"
+        return "Not in dataset"
+
     def generate_targeted_error_object(  # noqa: C901
         self, targets: Iterable[str], data: pd.DataFrame, message: str
     ) -> ValidationErrorContainer:
@@ -143,8 +159,9 @@ def generate_targeted_error_object(  # noqa: C901
 
         if self.rule.get("sensitivity") == Sensitivity.DATASET.value:
             # Only generate one error for rules with dataset sensitivity
+            missing_var_msg = self._get_missing_variable_message()
             missing_vars = {
-                target: "Not in dataset" for target in targets_not_in_dataset
+                target: missing_var_msg for target in targets_not_in_dataset
             }
 
             # Create the initial error
@@ -220,6 +237,8 @@ def generate_targeted_error_object(  # noqa: C901
             errors_list = self._generate_errors_by_target_presence(
                 data, targets_not_in_dataset, all_targets_missing, errors_df
             )
+
+        compare_groups = self._extract_comparison_metadata(self.rule)
         return ValidationErrorContainer(
             domain=(
                 f"SUPP{self.dataset_metadata.rdomain}"
@@ -232,6 +251,7 @@ def generate_targeted_error_object(  # noqa: C901
             targets=targets_list,
             errors=errors_list,
             message=message.replace("--", self.dataset_metadata.domain_cleaned or ""),
+            compare_groups=compare_groups,
         )
 
     def _generate_errors_by_target_presence(
@@ -254,14 +274,15 @@ def _generate_errors_by_target_presence(
         Returns:
             List of ValidationErrorEntity objects
         """
-        missing_vars = {target: "Not in dataset" for target in targets_not_in_dataset}
+        missing_var_msg = self._get_missing_variable_message()
+        missing_vars = {target: missing_var_msg for target in targets_not_in_dataset}
 
         if all_targets_missing:
             errors_list = []
             for idx, row in data.iterrows():
                 error = ValidationErrorEntity(
                     value={
-                        target: "Not in dataset" for target in targets_not_in_dataset
+                        target: missing_var_msg for target in targets_not_in_dataset
                     },
                     dataset=self._get_dataset_name(pd.DataFrame([row])),
                     row=int(row.get(SOURCE_ROW_NUMBER, idx + 1)),
@@ -383,17 +404,16 @@ def _build_complete_error_value(
         errors_df,
     ):
         """Build complete error value with all components."""
+        missing_var_msg = self._get_missing_variable_message()
         if all_targets_missing:
-            error_value = {
-                target: "Not in dataset" for target in targets_not_in_dataset
-            }
+            error_value = {target: missing_var_msg for target in targets_not_in_dataset}
         else:
             error_value = self._build_error_value_from_row(first_row_idx, errors_df)
         error_value = self._add_group_keys_to_error_value(
             error_value, group_keys, grouping_variables
         )
 
-        missing_vars = {target: "Not in dataset" for target in targets_not_in_dataset}
+        missing_vars = {target: missing_var_msg for target in targets_not_in_dataset}
         if missing_vars:
             error_value = {**error_value, **missing_vars}
 
@@ -509,6 +529,51 @@ def extract_target_names_from_value_level_metadata(self) -> List[str]:
                 ordered.append(name)
         return ordered
 
+    def _extract_comparison_metadata(self, rule: dict) -> Optional[List[List[str]]]:
+        """
+        Extract comparison metadata from rule's output_variables.
+
+        Supports mixed lists with inline `compared` blocks, e.g.:
+        Output Variables:
+          - $sibling_1
+          - compared:
+              - $child_A
+              - $child_B
+              - $child_C
+
+        Returns:
+            List of comparison groups (each group is a list of variable names),
+            or None if no comparison groups are defined.
+        """
+        if "_cached_compare_groups" in rule:
+            return rule["_cached_compare_groups"]
+
+        output_variables = rule.get("output_variables", []) or []
+
+        flattened: List[str] = []
+        comparison_groups: List[List[str]] = []
+
+        for item in output_variables:
+            if isinstance(item, dict) and "compared" in item:
+                children = item.get("compared", [])
+                if isinstance(children, list):
+                    valid_children = [c for c in children if isinstance(c, str)]
+                    flattened.extend(valid_children)
+                    if len(valid_children) >= 2:
+                        comparison_groups.append(valid_children)
+            elif isinstance(item, str):
+                flattened.append(item)
+
+        result = comparison_groups if comparison_groups else None
+        rule["_cached_compare_groups"] = result
+
+        if flattened:
+            current_vars = rule.get("output_variables", [])
+            if any(isinstance(item, dict) for item in current_vars):
+                rule["output_variables"] = flattened
+
+        return result
+
     @staticmethod
     def _sequence_exists(sequence: pd.Series, row_name: Hashable) -> bool:
         return (

cdisc_rules_engine/models/validation_error_container.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import List, Optional
 from dataclasses import dataclass, field
 from cdisc_rules_engine.utilities.utils import get_execution_status
 
@@ -18,13 +18,14 @@ class ValidationErrorContainer(BaseValidationEntity):
     message: str | None = None
     status: str | None = None
     entity: str | None = None
+    compare_groups: Optional[List[List[str]]] = None
 
     @property
     def executionStatus(self):
         return self.status or get_execution_status(self.errors)
 
     def to_representation(self) -> dict:
-        return {
+        result = {
             "executionStatus": self.executionStatus,
             "dataset": self.dataset,
             "domain": self.domain,
@@ -33,3 +34,6 @@ def to_representation(self) -> dict:
             "errors": [error.to_representation() for error in self.errors],
             **({"entity": self.entity} if self.entity else {}),
         }
+        if self.compare_groups:
+            result["compare_groups"] = self.compare_groups
+        return result

cdisc_rules_engine/services/reporting/base_report_data.py

@@ -47,7 +47,12 @@ def process_values(values: list[str]) -> list[str]:
             if value is None:
                 processed_values.append("null")
                 continue
-            value = value.strip()
+            if isinstance(value, str) and "\n" in value:
+                lines = value.split("\n")
+                stripped_lines = [line.rstrip() for line in lines]
+                value = "\n".join(stripped_lines).strip()
+            elif isinstance(value, str):
+                value = value.strip()
             if value == "" or value.lower() == "nan":
                 processed_values.append("null")
             else:

cdisc_rules_engine/services/reporting/excel_writer.py

@@ -35,9 +35,17 @@ def excel_update_worksheet(ws, rows, align_params=None, fill_empty_rows=False):
             ws.cell(row=row_data.row, column=2).value = row_data.value
         else:
             for col_num, col_data in enumerate(row_data.values(), 1):
-                ws.cell(row=row_num, column=col_num).value = stringify_list(col_data)
+                cell_value = stringify_list(col_data)
+                ws.cell(row=row_num, column=col_num).value = cell_value
+                if align_params:
+                    alignment_params = align_params.copy()
+                else:
+                    alignment_params = {}
+                if isinstance(cell_value, str) and "\n" in cell_value:
+                    alignment_params["wrap_text"] = True
+                    alignment_params["vertical"] = "top"
                 ws.cell(row=row_num, column=col_num).alignment = Alignment(
-                    **align_params
+                    **alignment_params
                 )
                 if fill_empty_rows and (row_data[1] == "" or row_data[1] is None):
                     # Codelist is empty for Code Rows. Change background color