missing all outcome vars logic changed (#1110)

* missing all outcome vars logic changed

* updated logic

* update

* updated logic

* updated logic

Author: SFJohnson24

cdisc_rules_engine/exceptions/custom_exceptions.py

@@ -33,11 +33,6 @@ class InvalidMatchKeyError(EngineError):
     description = "Invalid match key provided"
 
 
-class InvalidOutputVariables(EngineError):
-    code = 400
-    description = "Invalid output variables"
-
-
 class VariableMetadataNotFoundError(EngineError):
     code = 400
     description = (

cdisc_rules_engine/models/actions.py

@@ -10,7 +10,6 @@
     SOURCE_ROW_NUMBER,
 )
 from cdisc_rules_engine.enums.sensitivity import Sensitivity
-from cdisc_rules_engine.exceptions.custom_exceptions import InvalidOutputVariables
 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 (
@@ -120,26 +119,41 @@ def generate_targeted_error_object(
         df_columns: set = set(data)
         targets_in_dataset = targets.intersection(df_columns)
         targets_not_in_dataset = targets.difference(df_columns)
-        errors_df = data[list(targets_in_dataset)]
+        all_targets_missing = (
+            len(targets_in_dataset) == 0 and len(targets_not_in_dataset) > 0
+        )
+        if targets_in_dataset:
+            errors_df = data[list(targets_in_dataset)]
+        else:
+            errors_df = data
         if not targets:
             errors_df = data
-        if errors_df.empty:
-            raise InvalidOutputVariables(
-                f"Output variables: {list(targets)} not found in dataset"
-            )
+
         if self.rule.get("sensitivity") == Sensitivity.DATASET.value:
             # Only generate one error for rules with dataset sensitivity
+            missing_vars = {
+                target: "Not in dataset" for target in targets_not_in_dataset
+            }
+
+            # Create the initial error
+            error_value = (
+                dict(errors_df.iloc[0].to_dict()) if not all_targets_missing else {}
+            )
+
+            # Add missing variables to the error value
+            if missing_vars:
+                error_value = {**error_value, **missing_vars}
+
             errors_list = [
                 ValidationErrorEntity(
-                    value=dict(errors_df.iloc[0].to_dict()),
+                    value=error_value,
                     dataset=self._get_dataset_name(data),
                 )
             ]
         elif self.rule.get("sensitivity") == Sensitivity.RECORD.value:
-            errors_series: pd.Series = errors_df.apply(
-                lambda df_row: self._create_error_object(df_row, data), axis=1
+            errors_list = self._generate_errors_by_target_presence(
+                data, targets_not_in_dataset, all_targets_missing, errors_df
             )
-            errors_list: List[ValidationErrorEntity] = errors_series.tolist()
         elif (
             self.rule.get("sensitivity") is not None
         ):  # rule sensitivity is incorrectly defined
@@ -163,14 +177,9 @@ def generate_targeted_error_object(
                 errors=[error_entity],
             )
         else:  # rule sensitivity is undefined
-            errors_series: pd.Series = errors_df.apply(
-                lambda df_row: self._create_error_object(df_row, data), axis=1
+            errors_list = self._generate_errors_by_target_presence(
+                data, targets_not_in_dataset, all_targets_missing, errors_df
             )
-            errors_list: List[ValidationErrorEntity] = errors_series.tolist()
-        missing_vars = {target: "Not in dataset" for target in targets_not_in_dataset}
-        if missing_vars:
-            for error in errors_list:
-                error.value = {**error.value, **missing_vars}
         return ValidationErrorContainer(
             **{
                 "domain": (
@@ -187,6 +196,69 @@ def generate_targeted_error_object(
             }
         )
 
+    def _generate_errors_by_target_presence(
+        self,
+        data: pd.DataFrame,
+        targets_not_in_dataset: Set[str],
+        all_targets_missing: bool,
+        errors_df: pd.DataFrame,
+    ) -> List[ValidationErrorEntity]:
+        """
+        Generate error list based on presence of target variables in the dataset.
+        Handles two cases: (1) when all targets are missing, or (2) when some targets are present.
+
+        Args:
+            data: The original dataframe
+            targets_not_in_dataset: Set of target variables not found in the dataset
+            all_targets_missing: Boolean indicating if all targets are missing
+            errors_df: DataFrame subset with only the target variables (if any exist)
+
+        Returns:
+            List of ValidationErrorEntity objects
+        """
+        missing_vars = {target: "Not in dataset" 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
+                    },
+                    dataset=self._get_dataset_name(pd.DataFrame([row])),
+                    row=int(row.get(SOURCE_ROW_NUMBER, idx + 1)),
+                    usubjid=(
+                        str(row.get("USUBJID"))
+                        if "USUBJID" in row and not pd.isna(row["USUBJID"])
+                        else None
+                    ),
+                    sequence=(
+                        int(row.get(f"{self.dataset_metadata.domain or ''}SEQ"))
+                        if f"{self.dataset_metadata.domain or ''}SEQ" in row
+                        and self._sequence_exists(
+                            pd.Series(
+                                {
+                                    idx: row.get(
+                                        f"{self.dataset_metadata.domain or ''}SEQ"
+                                    )
+                                }
+                            ),
+                            idx,
+                        )
+                        else None
+                    ),
+                )
+                errors_list.append(error)
+        else:
+            errors_series: pd.Series = errors_df.apply(
+                lambda df_row: self._create_error_object(df_row, data), axis=1
+            )
+            errors_list: List[ValidationErrorEntity] = errors_series.tolist()
+            if missing_vars:
+                for error in errors_list:
+                    error.value = {**error.value, **missing_vars}
+        return errors_list
+
     def _get_dataset_name(self, data: pd.DataFrame) -> str:
         source_pathnames = data.get(SOURCE_FILENAME, [])
         source_filenames = [

cdisc_rules_engine/operations/base_operation.py

@@ -30,7 +30,6 @@
     RuleExecutionError,
     RuleFormatError,
     InvalidMatchKeyError,
-    InvalidOutputVariables,
     VariableMetadataNotFoundError,
     DomainNotFoundInDefineXMLError,
     InvalidDatasetFormat,
@@ -79,7 +78,6 @@ def execute(self) -> DatasetInterface:
             RuleExecutionError,
             RuleFormatError,
             InvalidMatchKeyError,
-            InvalidOutputVariables,
             VariableMetadataNotFoundError,
             DomainNotFoundInDefineXMLError,
             InvalidDatasetFormat,