Fix issue with params short format and add regression test

Author: polyaxon-ci

cli/polyaxon/_flow/operations/operation.py

@@ -7,7 +7,7 @@
     StrictStr,
     field_validator,
     model_validator,
-    validation_after,
+    validation_after, validation_before,
 )
 from clipped.config.patch_strategy import PatchStrategy
 from clipped.config.schema import skip_partial, to_partial
@@ -16,7 +16,7 @@
 from polyaxon._flow.component.component import V1Component
 from polyaxon._flow.hooks import V1Hook
 from polyaxon._flow.operations.base import BaseOp
-from polyaxon._flow.params import V1Param
+from polyaxon._flow.params import V1Param, normalize_param_value
 from polyaxon._flow.references import V1DagRef, V1HubRef, V1PathRef, V1UrlRef
 from polyaxon._flow.run.patch import validate_run_patch
 from polyaxon._flow.templates import TemplateMixinConfig, V1Template
@@ -544,6 +544,13 @@ class V1Operation(BaseOp, TemplateMixinConfig):
     run_patch: Optional[Dict] = Field(alias="runPatch", default=None)
     template: Optional[V1Template] = None
 
+    @field_validator("params", **validation_before)
+    @classmethod
+    def validate_params(cls, params):
+        if not params:
+            return params
+        return {k: normalize_param_value(v) for k, v in params.items()}
+
     @model_validator(**validation_after)
     @skip_partial
     def validate_reference(cls, values):

cli/polyaxon/_flow/params/params.py

@@ -56,6 +56,9 @@ def is_short_form_param(value: Any) -> bool:
     Returns:
         True if the value is in short-form, False if it's a full-form V1Param dict
     """
+    if isinstance(value, V1Param):
+        return False
+
     if not isinstance(value, Mapping):
         # Non-dict values are always short-form
         return True

cli/tests/fixtures/typing/required_inputs_with_short_params.yml

@@ -0,0 +1,20 @@
+---
+version:  1.1
+kind: operation
+params:
+  loss: MeanSquaredError
+  flag: true
+component:
+  tags: [foo, bar]
+  inputs:
+    - name: loss
+      type: str
+    - name: flag
+      type: bool
+      isFlag: true
+  run:
+    kind: job
+    container:
+      image: my_image
+      command: ["/bin/sh", "-c"]
+      args: video_prediction_train --loss={{loss}} {{ flag }}

cli/tests/test_polyaxonfile/test_polyaxonfile.py

@@ -227,6 +227,35 @@ def test_passing_params_overrides_polyaxonfiles(self):
             == "video_prediction_train --loss=some-loss --flag"
         )
 
+    def test_passing_short_params_overrides_polyaxonfiles(self):
+        # Test that short form params (without the "value" wrapper) are parsed correctly
+        op_config = OperationSpecification.read(
+            [
+                os.path.abspath(
+                    "tests/fixtures/typing/required_inputs_with_short_params.yml"
+                ),
+            ]
+        )
+
+        # Verify params are parsed correctly from short form
+        assert op_config.params["loss"].value == "MeanSquaredError"
+        assert op_config.params["flag"].value is True
+
+        # Compile the operation and apply params
+        run_config = OperationSpecification.compile_operation(op_config)
+        # Apply the params from the operation to the compiled operation
+        run_config.apply_params(params=op_config.params)
+        run_config = CompiledOperationSpecification.apply_operation_contexts(run_config)
+        run_config = CompiledOperationSpecification.apply_runtime_contexts(run_config)
+        assert run_config.version == 1.1
+        assert run_config.tags == ["foo", "bar"]
+        assert run_config.run.container.image == "my_image"
+        assert run_config.run.container.command == ["/bin/sh", "-c"]
+        assert (
+            run_config.run.container.args
+            == "video_prediction_train --loss=MeanSquaredError --flag"
+        )
+
     def test_passing_wrong_params_raises(self):
         with self.assertRaises(PolyaxonfileError):
             check_polyaxonfile(
@@ -830,3 +859,4 @@ def test_specification_with_context_requirement(self):
             run_config, contexts=contexts
         )
         assert run_config.run.to_dict() == expected_run
+