requested changes

Author: CIGbalance

utils/requirements.txt

@@ -1 +1,2 @@
 pyyaml
+pandas

utils/validate_yaml.py

@@ -1,25 +1,18 @@
 import yaml
+
 import sys
+from pathlib import Path
+
+# Add parent directory to sys.path
+parent = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(parent))
+
+# Now you can import normally
+from yaml_to_html import default_columns as REQUIRED_FIELDS
 
-# Define the required fields your YAML must have
-REQUIRED_FIELDS = [
-    "name",
-    "suite/generator/single",
-    "objectives",
-    "dimensionality",
-    "variable type",
-    "constraints",
-    "dynamic",
-    "noise",
-    "multimodal",
-    "multi-fidelity",
-    "reference",
-    "implementation",
-    "source (real-world/artificial)",
-    "textual description",
-]
-
-UNIQUE_FIELDS = ["name", "reference", "implementation"]
+OPTIONAL_FIELDS = ["multimodal"]
+UNIQUE_FIELDS = ["name"]
+UNIQUE_WARNING_FIELDS = ["reference", "implementation"]
 PROBLEMS_FILE = "problems.yaml"
 
 
@@ -29,34 +22,48 @@ def read_data(filepath):
             data = yaml.safe_load(f)
             return 0, data
     except FileNotFoundError:
-        print(f"File not found: {filepath}")
+        print(f"::error::File not found: {filepath}")
         return 1, None
     except yaml.YAMLError as e:
-        print(f"YAML syntax error: {e}")
+        print(f"::error::YAML syntax error: {e}")
         return 1, None
 
 
 def check_format(data):
-    if len(data) != 1:
-        print("YAML file should contain exactly one top-level document.")
-        return False
-    if not isinstance(data[0], dict):
-        print("Top-level document should be a dictionary.")
+    num_problems = len(data)
+    if len(data) < 1:
+        print("::error::YAML file should contain at least one top level entry.")
         return False
+    print(f"::notice::YAML file contains {num_problems} top-level entries.")
+    unique_fields = []
+    for i, entry in enumerate(data):
+        if not isinstance(entry, dict):
+            print(f"::error::Entry {i} is not a dictionary.")
+            return False
+        unique_fields.append({k: v for k, v in entry.items() if k in UNIQUE_FIELDS})
+    for k in UNIQUE_FIELDS:
+        values = [entry[k] for entry in unique_fields]
+        if len(values) != len(set(values)):
+            print(f"::error::Field '{k}' must be unique across all entries.")
+            return False
     return True
 
 
 def check_fields(data):
-    if len(data) != len(REQUIRED_FIELDS):
-        print(f"YAML file should contain exactly {len(REQUIRED_FIELDS)} fields.")
-        return False
     missing = [field for field in REQUIRED_FIELDS if field not in data]
     if missing:
-        print(f"Missing required fields: {', '.join(missing)}")
+        print(f"::error::Missing required fields: {', '.join(missing)}")
         return False
+    new_fields = [
+        field for field in data if field not in REQUIRED_FIELDS + OPTIONAL_FIELDS
+    ]
+    if new_fields:
+        print(f"::warning::New field added: {', '.join(new_fields)}")
     # Check that the name is not still template
     if data.get("name") == "template":
-        print("Please change the 'name' field from 'template' to a unique name.")
+        print(
+            "::error::Please change the 'name' field from 'template' to a unique name."
+        )
         return False
     return True
 
@@ -65,18 +72,24 @@ def check_novelty(data):
     # Load existing problems
     read_status, existing_data = read_data(PROBLEMS_FILE)
     if read_status != 0:
-        print("Could not read existing problems for novelty check.")
+        print("::eror::Could not read existing problems for novelty check.")
         return False
     assert existing_data is not None
-    for field in UNIQUE_FIELDS:
+    for field in UNIQUE_FIELDS or UNIQUE_WARNING_FIELDS:
         existing_values = {
             entry.get(field) for entry in existing_data if isinstance(entry, dict)
         }
         if data.get(field) in existing_values:
-            print(
-                f"Field '{field}' with value '{data.get(field)}' already exists. Please choose a unique value."
-            )
-            return False
+            if field in UNIQUE_WARNING_FIELDS:
+                print(
+                    f"::warning::Field '{field}' with value '{data.get(field)}' already exists. Consider choosing a unique value."
+                )
+                continue
+            elif field in UNIQUE_FIELDS:
+                print(
+                    f"::error::Field '{field}' with value '{data.get(field)}' already exists. Please choose a unique value."
+                )
+                return False
     return True
 
 
@@ -86,12 +99,13 @@ def validate_yaml(filepath):
         sys.exit(1)
     if not check_format(data):
         sys.exit(1)
-    assert data is not None and len(data) == 1
-    new_data = data[0]  # Extract the single top-level entry
+    assert data is not None
 
-    # Check required and unique fields
-    if not check_fields(new_data) or not check_novelty(new_data):
-        sys.exit(1)
+    for i, new_data in enumerate(data):  # Iterate through each top-level entry
+        # Check required and unique fields
+        if not check_fields(new_data) or not check_novelty(new_data):
+            print(f"::error::Validation failed for entry {i+1}.")
+            sys.exit(1)
 
     # YAML is valid if we reach this point
     print("YAML syntax is valid.")
@@ -100,7 +114,7 @@ def validate_yaml(filepath):
 
 if __name__ == "__main__":
     if len(sys.argv) < 2:
-        print("Usage: python validate_yaml.py <yourfile.yaml>")
+        print("::error::Usage: python validate_yaml.py <yourfile.yaml>")
         sys.exit(1)
 
     filepath = sys.argv[1]