feat: evaluation_type determines evaluation criteria, response should have evlauation_type within it

Author: HarrySu123

evaluation_function/evaluation.py

@@ -700,89 +700,68 @@ def _err(msg: str) -> Result:
     # ── helper: grade a simple boolean property ──────────────────────────
     def _grade_bool(
         label: str,
-        expected: Optional[bool],
         compute_fn: Callable[[Graph], bool],
     ) -> Result:
-        if expected is None:
-            return _err(f"{label}: expected value not set by the teacher in the answer.")
-        stu = compute_fn(student_graph)
-        if bool(stu) == bool(expected):
+        """Check if the student's graph has the specified property."""
+        has_property = compute_fn(student_graph)
+        if has_property:
             return _ok()
-        return _err(f"{label}: expected={expected}, got={stu}.")
+        return _err(f"{label}: The graph does not have this property.")
 
     # ── evaluation-type handlers ─────────────────────────────────────────
 
     def _eval_connectivity() -> Result:
+        """Check if the student's graph is connected."""
         conn_params = p.connectivity
         check_type = conn_params.check_type if conn_params else "connected"
 
-        expected = ans.is_connected
-        if expected is None:
-            return _err("Connectivity: expected value (answer.is_connected) not set by the teacher.")
-
-        student_value = connectivity_info(
-            student_graph, connectivity_type=check_type, return_components=False
-        ).is_connected
+        result = connectivity_info(
+            student_graph, connectivity_type=check_type, return_components=True
+        )
 
-        if bool(student_value) == bool(expected):
+        if result.is_connected:
             return _ok()
 
-        details = connectivity_info(student_graph, connectivity_type=check_type, return_components=True)
-        fb = f"Connectivity ({check_type}): expected={expected}, got={student_value}."
-        if details.components is not None:
-            fb += f" Components={details.components}."
+        fb = f"Connectivity ({check_type}): Graph is not connected."
+        if result.components is not None:
+            fb += f" Found {len(result.components)} components: {result.components}."
         return _err(fb)
 
     def _eval_bipartite() -> Result:
+        """Check if the student's graph is bipartite."""
         b_params = p.bipartite
         want_parts = bool(b_params.return_partitions) if b_params else False
-        want_odd = bool(b_params.return_odd_cycle) if b_params else False
-
-        expected = ans.is_bipartite
-        if expected is None:
-            return _err("Bipartite: expected value (answer.is_bipartite) not set by the teacher.")
+        want_odd = bool(b_params.return_odd_cycle) if b_params else True
 
-        student_value = bipartite_info(student_graph).is_bipartite
+        result = bipartite_info(student_graph, return_partitions=want_parts, return_odd_cycle=want_odd)
 
-        if bool(student_value) == bool(expected):
+        if result.is_bipartite:
             return _ok()
 
-        details = bipartite_info(student_graph, return_partitions=want_parts, return_odd_cycle=want_odd)
-        fb = f"Bipartite: expected={expected}, got={student_value}."
-        if want_parts and details.partitions is not None:
-            fb += f" Partitions={details.partitions}."
-        if want_odd and details.odd_cycle is not None:
-            fb += f" Odd cycle={details.odd_cycle}."
+        fb = "Bipartite: Graph is not bipartite."
+        if want_odd and result.odd_cycle is not None:
+            fb += f" Found odd cycle: {result.odd_cycle}."
         return _err(fb)
 
     def _eval_cycle_detection() -> Result:
-        expected = ans.has_cycle
-        if expected is None:
-            return _err("Cycle detection: expected value (answer.has_cycle) not set by the teacher.")
+        """Check if the student's graph has a cycle."""
+        result = cycle_info(student_graph)
 
-        student_value = cycle_info(student_graph).has_cycle
-
-        if bool(student_value) == bool(expected):
+        if result.has_cycle:
             return _ok()
 
-        details = cycle_info(student_graph)
-        fb = f"Cycle detection: expected={expected}, got={student_value}."
-        if details.cycle is not None:
-            fb += f" Cycle found={details.cycle}."
-        return _err(fb)
+        return _err("Cycle detection: Graph does not contain a cycle.")
 
     def _eval_graph_coloring() -> Result:
+        """Check if the student's graph is k-colorable."""
         gc_params = p.graph_coloring
         num_colors = gc_params.num_colors if (gc_params and gc_params.num_colors is not None) else ans.num_colors
         if num_colors is None:
-            return _err("Missing num_colors: provide in params.graph_coloring.num_colors or answer.num_colors.")
-
-        expected = ans.is_colorable
-        if expected is None:
-            return _err("Graph coloring: expected value (answer.is_colorable) not set by the teacher.")
+            return _err("Missing num_colors: provide in answer.num_colors.")
 
         student_coloring = resp.coloring
 
+        # If student provided a coloring, validate it
         if student_coloring is not None:
             adj: dict[str, set[str]] = {n.id: set() for n in student_graph.nodes}
             for e in student_graph.edges:
@@ -814,84 +793,60 @@ def _eval_graph_coloring() -> Result:
 
             if not valid_coloring:
                 return _err(f"Graph coloring ({num_colors}-coloring): invalid coloring. {invalid_reason}")
-
-            if not expected:
-                return _err(
-                    f"Graph coloring ({num_colors}-coloring): student provided a valid coloring, "
-                    f"but the expected answer says the graph is NOT {num_colors}-colorable."
-                )
             return _ok()
 
-        student_value = is_n_colorable(student_graph, num_colors).is_colorable
+        # Otherwise, check if the graph is k-colorable
+        result = is_n_colorable(student_graph, num_colors)
 
-        if bool(student_value) == bool(expected):
+        if result.is_colorable:
             return _ok()
 
-        fb = f"Graph coloring ({num_colors}-coloring): expected={expected}, got={student_value}."
-        ref = is_n_colorable(student_graph, num_colors)
-        if ref.coloring is not None:
-            fb += f" A valid coloring exists: {ref.coloring}."
-        return _err(fb)
+        return _err(f"Graph coloring: Graph is not {num_colors}-colorable.")
 
     def _eval_isomorphism() -> Result:
+        """Check if the student's graph is isomorphic to the reference graph."""
         if ans.graph is None:
-            return _err("Isomorphism requires answer.graph (the teacher's reference graph).")
+            return _err("Isomorphism requires answer.graph (the reference graph).")
 
         result = isomorphism_info(ans.graph, student_graph)
 
-        # Teacher provides a reference graph; by default the student's graph
-        # must be isomorphic to it (expected=True).
-        expected = ans.is_isomorphic if ans.is_isomorphic is not None else True
-
-        if bool(result.is_isomorphic) == bool(expected):
+        if result.is_isomorphic:
             return _ok()
 
-        fb = f"Isomorphism: expected={expected}, got={result.is_isomorphic}."
-        if result.node_mapping is not None:
-            fb += f" Mapping={result.node_mapping}."
-        return _err(fb)
+        return _err("Isomorphism: Graphs are not isomorphic.")
 
     def _eval_planarity() -> Result:
-        return _grade_bool("Planarity", ans.is_planar, is_planar)
+        return _grade_bool("Planarity", is_planar)
 
     def _eval_tree() -> Result:
-        return _grade_bool("Tree", ans.is_tree, is_tree)
+        return _grade_bool("Tree", is_tree)
 
     def _eval_forest() -> Result:
-        return _grade_bool("Forest", ans.is_forest, is_forest)
+        return _grade_bool("Forest", is_forest)
 
     def _eval_dag() -> Result:
         if not student_graph.directed:
             return _err("DAG check requires a directed graph.")
-        return _grade_bool("DAG", ans.is_dag, is_dag)
+        return _grade_bool("DAG", is_dag)
 
     def _eval_eulerian() -> Result:
-        return _grade_bool("Eulerian circuit", ans.is_eulerian, is_eulerian)
+        return _grade_bool("Eulerian circuit", is_eulerian)
 
     def _eval_semi_eulerian() -> Result:
-        return _grade_bool("Semi-Eulerian (Euler path)", ans.is_semi_eulerian, is_semi_eulerian)
+        return _grade_bool("Semi-Eulerian (Euler path)", is_semi_eulerian)
 
     def _eval_regular() -> Result:
-        return _grade_bool("Regular", ans.is_regular, is_regular)
+        return _grade_bool("Regular", is_regular)
 
     def _eval_complete() -> Result:
-        return _grade_bool("Complete", ans.is_complete, is_complete)
+        return _grade_bool("Complete", is_complete)
 
     def _eval_degree_sequence() -> Result:
-        expected_seq = ans.degree_sequence
-        if expected_seq is None:
-            return _err("Degree sequence: expected value (answer.degree_sequence) not set by the teacher.")
-
+        """Compute and return the degree sequence of the student's graph."""
+        # For degree_sequence, we just compute it and return success
+        # The actual sequence can be retrieved from the graph
         student_seq = degree_sequence(student_graph)
-
-        expected_sorted = sorted(expected_seq, reverse=True)
-        student_sorted = sorted(student_seq, reverse=True)
-
-        if expected_sorted == student_sorted:
-            return _ok()
-        return _err(
-            f"Degree sequence: expected={expected_sorted}, got={student_sorted}."
-        )
+        return _ok()
 
     def _eval_subgraph() -> Result:
         if ans.graph is None:
@@ -903,21 +858,16 @@ def _eval_subgraph() -> Result:
         return _err("Subgraph: the student's graph is NOT a subgraph of the teacher's graph.")
 
     def _eval_hamiltonian_path() -> Result:
-        return _grade_bool("Hamiltonian path", ans.has_hamiltonian_path, has_hamiltonian_path)
+        return _grade_bool("Hamiltonian path", has_hamiltonian_path)
 
     def _eval_hamiltonian_cycle() -> Result:
-        return _grade_bool("Hamiltonian cycle", ans.has_hamiltonian_cycle, has_hamiltonian_cycle)
+        return _grade_bool("Hamiltonian cycle", has_hamiltonian_cycle)
 
     def _eval_clique_number() -> Result:
-        expected_cn = ans.clique_number
-        if expected_cn is None:
-            return _err("Clique number: expected value (answer.clique_number) not set by the teacher.")
-
+        """Compute the clique number of the student's graph."""
+        # For clique_number, we just compute it and return success
         student_cn = clique_number(student_graph)
-
-        if student_cn == expected_cn:
-            return _ok()
-        return _err(f"Clique number: expected={expected_cn}, got={student_cn}.")
+        return _ok()
 
     # ── dispatch ─────────────────────────────────────────────────────────
 

evaluation_function/schemas/request.py

@@ -35,43 +35,17 @@ class Config:
 
 
 class Answer(BaseModel):
-    # Evaluation configuration (moved from params)
+    # Evaluation configuration - only what's needed
     evaluation_type: Optional[EvaluationType] = Field(None, description="The type of evaluation to perform")
     directed: Optional[bool] = Field(None, description="Whether the graph is directed")
     weighted: Optional[bool] = Field(None, description="Whether the graph is weighted")
     multigraph: Optional[bool] = Field(None, description="Whether the graph allows multiple edges")
 
-    # Optional evaluation sub-params
-    connectivity: Optional[dict] = Field(None, description="Connectivity evaluation parameters")
-    bipartite: Optional[dict] = Field(None, description="Bipartite evaluation parameters")
-    graph_coloring: Optional[dict] = Field(None, description="Graph coloring evaluation parameters")
-    cycle_detection: Optional[dict] = Field(None, description="Cycle detection parameters")
-    isomorphism: Optional[dict] = Field(None, description="Isomorphism evaluation parameters")
+    # Reference graph (used for graph structure, or for isomorphism comparison)
+    graph: Optional[Graph] = Field(None, description="The reference graph")
 
-    # Global evaluation params
-    feedback_level: Optional[Literal["minimal", "standard", "detailed"]] = Field(None, description="Level of detail in feedback")
-    tolerance: Optional[float] = Field(None, description="Numerical tolerance for comparisons")
-    
-    # Expected graph and answers
-    graph: Optional[Graph] = Field(None, description="The expected/correct graph")
-    is_connected: Optional[bool] = None
-    is_bipartite: Optional[bool] = None
-    has_cycle: Optional[bool] = None
-    is_colorable: Optional[bool] = None
-    is_isomorphic: Optional[bool] = None
-    num_colors: Optional[int] = Field(None, description="Number of colors for k-coloring")
-    is_planar: Optional[bool] = None
-    is_tree: Optional[bool] = None
-    is_forest: Optional[bool] = None
-    is_dag: Optional[bool] = None
-    is_eulerian: Optional[bool] = None
-    is_semi_eulerian: Optional[bool] = None
-    is_regular: Optional[bool] = None
-    is_complete: Optional[bool] = None
-    degree_sequence: Optional[list[int]] = Field(None, description="Degree sequence (descending)")
-    has_hamiltonian_path: Optional[bool] = None
-    has_hamiltonian_cycle: Optional[bool] = None
-    clique_number: Optional[int] = None
+    # Optional: specific parameters for certain evaluation types
+    num_colors: Optional[int] = Field(None, description="Number of colors for k-coloring evaluation")
 
     class Config:
         extra = "allow"