feat: for optional parameters allow using the default value as constant value (#916)

* feat(gui): add omitted variant to value forms

* feat(backend): process OmittedAnnotation

* feat(parser): generate value annotations with variant "omitted"

* chore(data): generate annotations

* style: apply automatic fixes of linters

Co-authored-by: lars-reimann <lars-reimann@users.noreply.github.com>

Author: lars-reimann

package-parser/package_parser/processing/annotations/_generate_value_annotations.py

@@ -3,6 +3,7 @@
 from package_parser.processing.annotations.model import (
     AnnotationStore,
     ConstantAnnotation,
+    OmittedAnnotation,
     OptionalAnnotation,
     RequiredAnnotation,
     ValueAnnotation,
@@ -45,6 +46,18 @@ def _generate_constant_annotation(
     :param annotations: AnnotationStore object
     """
 
+    # Always set to original default value
+    if sole_stringified_value == parameter.default_value:
+        annotations.valueAnnotations.append(
+            OmittedAnnotation(
+                target=parameter.id,
+                authors=[autogen_author],
+                reviewers=[],
+                comment=f"I omitted this parameter because it is always set to the original default value ({parameter.default_value}).",
+            )
+        )
+        return
+
     default_value_type, default_value = _get_type_and_value_for_stringified_value(
         sole_stringified_value
     )

package-parser/package_parser/processing/annotations/model/__init__.py

@@ -6,6 +6,7 @@
     EnumAnnotation,
     EnumPair,
     Interval,
+    OmittedAnnotation,
     OptionalAnnotation,
     ParameterInfo,
     ParameterType,

package-parser/package_parser/processing/annotations/model/_annotations.py

@@ -57,6 +57,7 @@ class EnumAnnotation(AbstractAnnotation):
 class ValueAnnotation(AbstractAnnotation, ABC):
     class Variant(Enum):
         CONSTANT = "constant"
+        OMITTED = "omitted"
         OPTIONAL = "optional"
         REQUIRED = "required"
 
@@ -87,6 +88,20 @@ def to_json(self) -> dict:
         }
 
 
+@dataclass
+class OmittedAnnotation(ValueAnnotation):
+    variant = ValueAnnotation.Variant.OMITTED
+
+    def to_json(self) -> dict:
+        return {
+            "target": self.target,
+            "authors": self.authors,
+            "reviewers": self.reviewers,
+            "comment": self.comment,
+            "variant": self.variant.value,
+        }
+
+
 @dataclass
 class OptionalAnnotation(ValueAnnotation):
     variant = ValueAnnotation.Variant.OPTIONAL

package-parser/tests/data/valueAnnotations/annotation_data.json

@@ -26,23 +26,14 @@
         "defaultValueType": "string",
         "defaultValue": "test"
     },
-    "test/test/UsedClass/used_method/constant_optional_parameter": {
-        "target": "test/test/UsedClass/used_method/constant_optional_parameter",
-        "authors": ["$autogen$"],
-        "reviewers": [],
-        "comment": "I replaced this parameter with a constant because it is always set to the same literal value (0.5).",
-        "variant": "constant",
-        "defaultValueType": "number",
-        "defaultValue": 0.5
-    },
     "test/test/some_global_function/optional_parameter_that_should_be_constant": {
         "target": "test/test/some_global_function/optional_parameter_that_should_be_constant",
         "authors": ["$autogen$"],
         "reviewers": [],
-        "comment": "I replaced this parameter with a constant because it is always set to the same literal value ('test').",
+        "comment": "I replaced this parameter with a constant because it is always set to the same literal value ('test2').",
         "variant": "constant",
         "defaultValueType": "string",
-        "defaultValue": "test"
+        "defaultValue": "test2"
     },
     "test/test/some_global_function/required_parameter_that_should_be_constant": {
         "target": "test/test/some_global_function/required_parameter_that_should_be_constant",
@@ -53,6 +44,20 @@
         "defaultValueType": "string",
         "defaultValue": "test"
     },
+    "test/test/UsedClass/used_method/constant_optional_parameter": {
+        "target": "test/test/UsedClass/used_method/constant_optional_parameter",
+        "authors": ["$autogen$"],
+        "reviewers": [],
+        "comment": "I omitted this parameter because it is always set to the original default value (0.5).",
+        "variant": "omitted"
+    },
+    "test/test/some_global_function/optional_parameter_that_should_be_omitted": {
+        "target": "test/test/some_global_function/optional_parameter_that_should_be_omitted",
+        "authors": ["$autogen$"],
+        "reviewers": [],
+        "comment": "I omitted this parameter because it is always set to the original default value (np.nan).",
+        "variant": "omitted"
+    },
     "test/test/some_global_function/required_parameter_that_should_be_optional": {
         "target": "test/test/some_global_function/required_parameter_that_should_be_optional",
         "authors": ["$autogen$"],

package-parser/tests/data/valueAnnotations/api_data.json

@@ -226,6 +226,12 @@
                     "qname": "test.some_global_function.optional_parameter_that_should_be_constant",
                     "default_value": "'test'"
                 },
+                {
+                    "id": "test/test/some_global_function/optional_parameter_that_should_be_omitted",
+                    "name": "optional_parameter_that_should_be_omitted",
+                    "qname": "test.some_global_function.optional_parameter_that_should_be_omitted",
+                    "default_value": "np.nan"
+                },
                 {
                     "id": "test/test/some_global_function/optional_parameter_that_should_be_required",
                     "name": "optional_parameter_that_should_be_required",

package-parser/tests/data/valueAnnotations/usage_data.json

@@ -30,7 +30,8 @@
         "test/test/some_global_function/required_parameter_that_should_be_required_with_non_string": 20,
         "test/test/some_global_function/required_parameter_that_should_be_optional": 20,
         "test/test/some_global_function/required_parameter_that_should_be_optional_with_non_string": 20,
-        "test/test/some_global_function/optional_parameter_that_should_be_constant": 0,
+        "test/test/some_global_function/optional_parameter_that_should_be_constant": 20,
+        "test/test/some_global_function/optional_parameter_that_should_be_omitted": 0,
         "test/test/some_global_function/optional_parameter_that_should_be_required": 8,
         "test/test/some_global_function/optional_parameter_that_should_be_required_with_non_string": 18,
         "test/test/some_global_function/optional_parameter_that_should_be_optional_with_same_default": 4,
@@ -106,7 +107,10 @@
             "non_string": 4,
             "'test2'": 13
         },
-        "test/test/some_global_function/optional_parameter_that_should_be_constant": {},
+        "test/test/some_global_function/optional_parameter_that_should_be_constant": {
+            "'test2'": 20
+        },
+        "test/test/some_global_function/optional_parameter_that_should_be_omitted": {},
         "test/test/some_global_function/optional_parameter_that_should_be_required": {
             "'test2'": 8
         },

package-parser/tests/processing/annotations/model/test_annotations.py

@@ -7,6 +7,7 @@
     EnumAnnotation,
     EnumPair,
     Interval,
+    OmittedAnnotation,
     OptionalAnnotation,
     RemoveAnnotation,
     RequiredAnnotation,
@@ -26,6 +27,29 @@ def test_base_annotation_to_json():
     }
 
 
+def test_boundary_annotation_to_json():
+    annotation = BoundaryAnnotation(
+        target="test/test",
+        authors=["$autogen$"],
+        reviewers=[],
+        comment="Autogenerated",
+        interval=Interval(False, 0, 0, 0, 0),
+    )
+    assert annotation.to_json() == {
+        "target": "test/test",
+        "authors": ["$autogen$"],
+        "reviewers": [],
+        "comment": "Autogenerated",
+        "interval": {
+            "isDiscrete": False,
+            "lowerIntervalLimit": 0,
+            "lowerLimitType": 0,
+            "upperIntervalLimit": 0,
+            "upperLimitType": 0,
+        },
+    }
+
+
 def test_constant_annotation_to_json():
     annotation = ConstantAnnotation(
         target="test/test",
@@ -46,23 +70,27 @@ def test_constant_annotation_to_json():
     }
 
 
-def test_remove_annotation_to_json():
-    annotation = RemoveAnnotation(
+def test_enum_annotation_to_json():
+    annotation = EnumAnnotation(
         target="test/test",
         authors=["$autogen$"],
         reviewers=[],
         comment="Autogenerated",
+        enumName="test",
+        pairs=[EnumPair("test", "test")],
     )
     assert annotation.to_json() == {
         "target": "test/test",
         "authors": ["$autogen$"],
         "reviewers": [],
         "comment": "Autogenerated",
+        "enumName": "test",
+        "pairs": [{"instanceName": "test", "stringValue": "test"}],
     }
 
 
-def test_required_annotation_to_json():
-    annotation = RequiredAnnotation(
+def test_omitted_annotation_to_json():
+    annotation = OmittedAnnotation(
         target="test/test",
         authors=["$autogen$"],
         reviewers=[],
@@ -73,7 +101,7 @@ def test_required_annotation_to_json():
         "authors": ["$autogen$"],
         "reviewers": [],
         "comment": "Autogenerated",
-        "variant": "required",
+        "variant": "omitted",
     }
 
 
@@ -97,45 +125,34 @@ def test_optional_annotation_to_json():
     }
 
 
-def test_boundary_annotation_to_json():
-    annotation = BoundaryAnnotation(
+def test_remove_annotation_to_json():
+    annotation = RemoveAnnotation(
         target="test/test",
         authors=["$autogen$"],
         reviewers=[],
         comment="Autogenerated",
-        interval=Interval(False, 0, 0, 0, 0),
     )
     assert annotation.to_json() == {
         "target": "test/test",
         "authors": ["$autogen$"],
         "reviewers": [],
         "comment": "Autogenerated",
-        "interval": {
-            "isDiscrete": False,
-            "lowerIntervalLimit": 0,
-            "lowerLimitType": 0,
-            "upperIntervalLimit": 0,
-            "upperLimitType": 0,
-        },
     }
 
 
-def test_enum_annotation_to_json():
-    annotation = EnumAnnotation(
+def test_required_annotation_to_json():
+    annotation = RequiredAnnotation(
         target="test/test",
         authors=["$autogen$"],
         reviewers=[],
         comment="Autogenerated",
-        enumName="test",
-        pairs=[EnumPair("test", "test")],
     )
     assert annotation.to_json() == {
         "target": "test/test",
         "authors": ["$autogen$"],
         "reviewers": [],
         "comment": "Autogenerated",
-        "enumName": "test",
-        "pairs": [{"instanceName": "test", "stringValue": "test"}],
+        "variant": "required",
     }