feat: Conditional parameters (HEXA-1687) (#1860)

* feat: Conditional parameters (HEXA-1687)

* feat: Disable params considered for validating schedule configs

* lint

* feat: disable by text and memoizing

* tests: tests cleanup

* remove not needed sets

* i18n

* feat: add text for deafult disabled params setting

* feat: normalize pipeline param dict values

* feat: update sdk

Author: mrivar

backend/hexa/pipelines/graphql/schema.graphql

@@ -134,6 +134,8 @@ type PipelineParameter {
   choices: [Generic!]  # The list of choices for the parameter.
   choicesFromFile: PipelineParameterChoicesFromFile  # Dynamic choices loaded from a workspace file.
   directory: String  # The name of the directory restriction (for file browser).
+  disables: [String!]!  # Codes of parameters disabled when this (boolean) parameter matches `disableWhen`.
+  disableWhen: Boolean!  # The boolean value of this parameter that triggers disabling of `disables` (default true).
 }
 
 """
@@ -152,6 +154,8 @@ input ParameterInput {
   choices: [Generic!]  # The list of choices for the parameter.
   choicesFromFile: PipelineParameterChoicesFromFileInput  # Dynamic choices loaded from a workspace file.
   directory: String  # The name of the directory restriction (for file browser).
+  disables: [String!]  # Codes of parameters disabled when this (boolean) parameter matches `disableWhen`.
+  disableWhen: Boolean  # The boolean value of this parameter that triggers disabling of `disables` (default true).
 }
 
 """

backend/hexa/pipelines/models.py

@@ -250,8 +250,31 @@ def validate_config_types(self, config: dict):
         if errors:
             raise ValueError(f"Parameters with invalid types: {', '.join(errors)}")
 
+    def get_disabled_parameter_codes(self, config: dict) -> set:
+        """Return the codes of parameters disabled by an active controller for the given config.
+
+        A controller is a boolean parameter declaring ``disables=[...]``. It is "active" when its effective
+        value (from ``config``, falling back to its ``default``) equals its ``disable_when`` (``True`` by
+        default). A parameter is disabled if any active controller lists it. This mirrors the SDK runtime and
+        the frontend run form so schedulability matches what a run would actually validate.
+        """
+        config = config or {}
+        disabled = set()
+        for parameter in self.parameters:
+            disables = parameter.get("disables")
+            if not disables:
+                continue
+            disable_when = parameter.get("disable_when", True)
+            effective_value = config.get(parameter["code"], parameter.get("default"))
+            if bool(effective_value) == disable_when:
+                disabled.update(disables)
+        return disabled
+
     def validate_new_config(self, new_config: dict):
+        disabled = self.get_disabled_parameter_codes(new_config)
         for parameter in self.parameters:
+            if parameter["code"] in disabled:
+                continue
             if (
                 parameter.get("required")
                 and parameter.get("default") is None
@@ -263,8 +286,10 @@ def validate_new_config(self, new_config: dict):
 
     @property
     def is_schedulable(self):
+        disabled = self.get_disabled_parameter_codes(self.config)
         return all(
-            parameter.get("required") is False
+            parameter["code"] in disabled
+            or parameter.get("required") is False
             or parameter.get("default") is not None
             or self.config.get(parameter["code"]) is not None
             for parameter in self.parameters

backend/hexa/pipelines/schema/mutations.py

@@ -1,5 +1,6 @@
 import base64
 import io
+import re
 import tempfile
 from pathlib import Path
 from zipfile import ZipFile
@@ -45,13 +46,36 @@ def get_bucket_object(bucket_name, file):
     return storage.get_bucket_object(bucket_name, file)
 
 
+_CAMEL_CASE_RE = re.compile(r"(?<!^)(?=[A-Z])")
+
+
+def _to_snake_case(name: str) -> str:
+    return _CAMEL_CASE_RE.sub("_", name).lower()
+
+
+def _normalize_parameter_keys(parameters: list) -> list:
+    """Convert top-level parameter keys to snake_case.
+
+    The SDK's ``to_dict()`` emits camelCase for multi-word keys (e.g. ``disableWhen``,
+    ``choicesFromFile``). On the explicit-upload path ariadne's ``convert_names_case`` normalizes
+    those to snake_case, but this zip-parsing path stores the dicts directly — so we normalize here
+    to keep the stored representation canonical (snake_case), which is what all readers expect.
+    """
+    return [
+        {_to_snake_case(key): value for key, value in param.items()}
+        for param in parameters
+    ]
+
+
 def _parse_parameters_from_zipfile(zipfile_data: bytes) -> list:
     try:
         with tempfile.TemporaryDirectory() as temp_dir:
             with ZipFile(io.BytesIO(zipfile_data), "r") as zip_file:
                 zip_file.extractall(temp_dir)
             sdk_pipeline = get_pipeline(Path(temp_dir))
-            return [p.to_dict() for p in sdk_pipeline.parameters]
+            return _normalize_parameter_keys(
+                [p.to_dict() for p in sdk_pipeline.parameters]
+            )
     except PipelineNotFound:
         return []
     except Exception as e:

backend/hexa/pipelines/schema/types.py

@@ -103,6 +103,16 @@ def resolve_pipeline_parameter_choices_from_file(parameter, info, **kwargs):
     return parameter.get("choices_from_file")
 
 
+@pipeline_parameter.field("disables")
+def resolve_pipeline_parameter_disables(parameter, info, **kwargs):
+    return parameter.get("disables") or []
+
+
+@pipeline_parameter.field("disableWhen")
+def resolve_pipeline_parameter_disable_when(parameter, info, **kwargs):
+    return parameter.get("disable_when", True)
+
+
 @pipeline_parameter_choices_from_file.field("format")
 def resolve_choices_from_file_format(obj, info, **kwargs):
     fmt = obj.get("format")

backend/hexa/pipelines/tests/test_pipelines_scheduler.py

@@ -6,6 +6,7 @@
 from hexa.core.test import TestCase
 from hexa.pipelines.models import (
     Pipeline,
+    PipelineDoesNotSupportParametersError,
     PipelineRun,
     PipelineRunState,
     PipelineRunTrigger,
@@ -322,3 +323,165 @@ def test_is_schedulable_false_when_pinned_version_unschedulable(self):
         self.PIPELINE.scheduled_pipeline_version = None
         self.PIPELINE.save()
         unschedulable_version.delete()
+
+    def _disabling_version(self, config):
+        return PipelineVersion.objects.create(
+            pipeline=self.PIPELINE,
+            name="disabling",
+            parameters=[
+                {
+                    "code": "run_report_only",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["data_input"],
+                },
+                {"code": "data_input", "type": "str", "required": True},
+            ],
+            config=config,
+        )
+
+    def test_schedulable_when_required_param_disabled_by_active_controller(self):
+        # Controller stored as on → data_input is disabled → required check waived.
+        version = self._disabling_version({"run_report_only": True})
+        self.assertTrue(version.is_schedulable)
+        version.delete()
+
+    def test_not_schedulable_when_controller_off_and_required_param_empty(self):
+        # Controller off (default) → data_input active and required with no value → not schedulable.
+        version = self._disabling_version({})
+        self.assertFalse(version.is_schedulable)
+        version.delete()
+
+    def test_schedulable_with_disable_when_false_controller_off(self):
+        version = PipelineVersion.objects.create(
+            pipeline=self.PIPELINE,
+            name="enable-toggle",
+            parameters=[
+                {
+                    "code": "enable_advanced",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["tuning"],
+                    "disable_when": False,
+                },
+                {"code": "tuning", "type": "str", "required": True},
+            ],
+            config={},
+        )
+        # enable_advanced off (default) matches disable_when=False → tuning disabled → schedulable.
+        self.assertTrue(version.is_schedulable)
+        version.delete()
+
+    def test_not_schedulable_with_disable_when_false_controller_on(self):
+        version = PipelineVersion.objects.create(
+            pipeline=self.PIPELINE,
+            name="enable-toggle-on",
+            parameters=[
+                {
+                    "code": "enable_advanced",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["tuning"],
+                    "disable_when": False,
+                },
+                {"code": "tuning", "type": "str", "required": True},
+            ],
+            config={"enable_advanced": True},
+        )
+        # Controller on → does NOT match disable_when=False → tuning active, required, empty → not schedulable.
+        self.assertFalse(version.is_schedulable)
+        version.delete()
+
+    def test_not_schedulable_when_controller_explicitly_false_in_config(self):
+        # Explicit False in config (not just default) keeps the required param active.
+        version = self._disabling_version({"run_report_only": False})
+        self.assertFalse(version.is_schedulable)
+        version.delete()
+
+    def test_schedulable_unions_multiple_controllers(self):
+        version = PipelineVersion.objects.create(
+            pipeline=self.PIPELINE,
+            name="multi-controller",
+            parameters=[
+                {
+                    "code": "toggle_a",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["x_param"],
+                },
+                {
+                    "code": "toggle_b",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["x_param", "y_param"],
+                },
+                {"code": "x_param", "type": "str", "required": True},
+                {"code": "y_param", "type": "str", "required": True},
+            ],
+            config={"toggle_a": True, "toggle_b": True},
+        )
+        self.assertTrue(version.is_schedulable)
+        version.delete()
+
+    def test_schedulable_when_required_disabled_param_has_no_default(self):
+        # Sanity: a disabled required param needs no default to be schedulable.
+        version = self._disabling_version({"run_report_only": True})
+        data_input = next(p for p in version.parameters if p["code"] == "data_input")
+        self.assertNotIn("default", data_input)
+        self.assertTrue(version.is_schedulable)
+        version.delete()
+
+    def test_get_disabled_parameter_codes_handles_none_config(self):
+        version = self._disabling_version({})
+        # Controller defaults to False → no params disabled.
+        self.assertEqual(version.get_disabled_parameter_codes(None), set())
+        version.delete()
+
+    def _scheduled_disabling_version(self, current_config):
+        """A version that currently has `data_input` set and is disabled-capable."""
+        return PipelineVersion.objects.create(
+            pipeline=self.PIPELINE,
+            name="scheduled-disabling",
+            parameters=[
+                {
+                    "code": "run_report_only",
+                    "type": "bool",
+                    "required": False,
+                    "default": False,
+                    "disables": ["data_input"],
+                },
+                {"code": "data_input", "type": "str", "required": True},
+            ],
+            config=current_config,
+        )
+
+    def test_validate_new_config_allows_dropping_disabled_required_param(self):
+        version = self._scheduled_disabling_version(
+            {"run_report_only": False, "data_input": "real_value"}
+        )
+        # New config turns the controller on → data_input disabled → dropping it is allowed.
+        version.validate_new_config({"run_report_only": True, "data_input": None})
+        version.delete()
+
+    def test_validate_new_config_rejects_dropping_active_required_param(self):
+        version = self._scheduled_disabling_version(
+            {"run_report_only": False, "data_input": "real_value"}
+        )
+        # Controller stays off → data_input active and required → dropping its value must raise.
+        with self.assertRaises(PipelineDoesNotSupportParametersError):
+            version.validate_new_config({"run_report_only": False, "data_input": None})
+        version.delete()
+
+    def test_validate_new_config_passes_when_value_kept(self):
+        version = self._scheduled_disabling_version(
+            {"run_report_only": False, "data_input": "real_value"}
+        )
+        version.validate_new_config(
+            {"run_report_only": False, "data_input": "still_here"}
+        )
+        version.delete()