Refactor EnrollmentRule handling of GROUPS and COURSES

app.py

@@ -1,8 +1,5 @@
 import gradio as gr
-import pydantic
-import random
-
-from pydantic import Field, field_validator, BaseModel
+from pydantic import BaseModel, Field, field_validator
 from enum import Enum
 from typing import List
 
@@ -12,8 +9,6 @@ class Group(str, Enum):
     marketing = "marketing"
     leadership = "leadership"
 
-GROUPS = ["onboarding", "sales enablement", "marketing", "leadership"]
-
 class Course(str, Enum):
     company_culture_and_values = "company culture and values"
     product_knowledge_and_features = "product knowledge and features"
@@ -32,89 +27,57 @@ class Course(str, Enum):
     change_management_and_organizational_development = "change management and organizational development"
     emotional_intelligence_and_communication_skills = "emotional intelligence and communication skills"
 
-COURSES = ["company culture and values",
-           "product knowledge and features",
-           "sales process and methodology",
-           "customer relationship management system training",
-           "sales enablement strategy and planning",
-           "content creation and curation",
-           "sales coaching and mentoring",
-           "sales metrics and analytics",
-           "digital marketing fundamentals",
-           "content marketing strategy",
-           "social media marketing",
-           "search engine optimization",
-           "leadership development and coaching",
-           "strategic planning and decision making",
-           "change management and organizational development",
-           "emotional intelligence and communication skills"
-           ]
-
 class EnrollmentRule(BaseModel):
     rule_code: str = Field(description="unique identifier code for the rule", default="")
     rule_name: str = Field(description="name of the rule", default="")
     group: Group = Field(description="group to apply the rule to", default=Group.onboarding)
-    courses: List[Course] = Field(description="list of courses that the members of the group will follow", default=[course.value for course in Course])
+    courses: List[Course] = Field(
+        description="list of courses that the members of the group will follow",
+        default_factory=lambda: list(Course)
+    )
 
     @field_validator("rule_code")
     def rule_code_max_length(cls, rule_code):
-        # Check if empty
         if not rule_code.strip():
             raise ValueError("The rule code cannot be empty.")
-        # Check length
         if len(rule_code) > 50:
             raise ValueError("The rule code must contain less than 50 characters.")
         return rule_code
+
     @field_validator("rule_name")
     def rule_name_max_length(cls, rule_name):
-        # Check if empty
         if not rule_name.strip():
             raise ValueError("The rule name cannot be empty.")
-        # Check length
         if len(rule_name) > 255:
             raise ValueError("The rule name must contain less than 255 characters.")
         return rule_name
-    @field_validator("group")
-    def group_is_valid(cls, group):
-        # Check if empty
-        if not group or not group.strip():
-            raise ValueError("Group cannot be empty.")
-        # Validate group value
-        if group.lower().strip() not in GROUPS:
-            raise ValueError(f"group '{group}' is not a valid value for field 'group'. 'group' must be one of the following: '{', '.join(GROUPS)}'")
-        return group
+
     @field_validator("courses")
-    def course_list_is_valid(cls, courses):
-        # Ensure at least one course is selected
+    def course_list_not_empty(cls, courses):
         if not courses:
             raise ValueError("At least one course must be provided.")
-
-        # Validate all listed courses
-        invalid_courses = []
-        for course in courses:
-            if course.lower().strip() not in COURSES:
-                invalid_courses.append(course)
-        if invalid_courses:
-            raise ValueError(f"course(s) '{', '.join(invalid_courses)}' is not a valid value for field 'courses'. 'course' must be one or more of the following: '{', '.join(COURSES)}'")
         return courses
-    
+
 def create_enrollment_rule(enrollment_rule: EnrollmentRule) -> dict:
-    """Create an enrollment rule, based on the rule parameters provided by the user"""
-    payload = enrollment_rule.model_dump(mode="json")
-    return payload
+    return enrollment_rule.model_dump(mode="json")
 
-# A small Gradio-friendly wrapper that converts user inputs into an EnrollmentRule
 def gr_create_enrollment_rule(rule_code, rule_name, group, courses):
-    # Build the Pydantic model from the raw inputs
+    # Convert group and courses from strings to enum values
+    # Pydantic will handle this automatically, but we need to ensure the raw inputs are enums.
+    # If the input is directly from the Gradio UI, they will be strings. Pydantic tries to coerce
+    # them into enum values. If it fails, it will raise a validation error.
     enrollment_rule = EnrollmentRule(
         rule_code=rule_code,
         rule_name=rule_name,
-        group=group,
-        courses=courses
+        group=Group(group),  # Will raise ValueError if invalid
+        courses=[Course(c) for c in courses]  # Will raise ValueError if invalid
     )
     return create_enrollment_rule(enrollment_rule)
 
-# Define the Gradio interface
+# Derive the choices from the Enums directly:
+GROUPS = [g.value for g in Group]
+COURSES = [c.value for c in Course]
+
 demo = gr.Interface(
     fn=gr_create_enrollment_rule,
     inputs=[