feat: moved configuration parameters into "params" from resposne

Author: HarrySu123

evaluation_function/evaluation.py

@@ -37,29 +37,21 @@
 
 def parse_frontend_graph(data: dict) -> Graph:
     """
-    Parse pipe-delimited frontend graph format into Graph object.
-    
+    Parse pipe-delimited frontend graph format into a Graph object (nodes + edges only).
+
     Frontend format:
     - nodes: ["id|label|x|y", ...]
     - edges: ["source|target|weight|label", ...]
-    - directed: boolean
-    - weighted: boolean
-    - multigraph: boolean
-    
-    Example:
-        {
-          "nodes": ["city1|New York|120|180"],
-          "edges": ["city1|city2|215|I-95 North"],
-          "directed": true,
-          "weighted": true,
-          "multigraph": false
-        }
-    
+
+    Note: directed/weighted/multigraph are NOT read from the data dict here.
+    They come exclusively from EvaluationParams and are applied later via
+    _apply_params_to_graph().
+
     Args:
         data: Dictionary with pipe-delimited node and edge strings
-        
+
     Returns:
-        Graph object with parsed nodes and edges
+        Graph object with only nodes and edges populated.
     """
     nodes = []
     edges = []
@@ -94,13 +86,9 @@ def parse_frontend_graph(data: dict) -> Graph:
             )
             edges.append(edge)
 
-    return Graph(
-        nodes=nodes,
-        edges=edges,
-        directed=data.get("directed", False),
-        weighted=data.get("weighted", False),
-        multigraph=data.get("multigraph", False)
-    )
+    # directed/weighted/multigraph are intentionally NOT read from the data dict.
+    # They come exclusively from EvaluationParams, applied via _apply_params_to_graph().
+    return Graph(nodes=nodes, edges=edges)
 
 
 def is_frontend_format(data: dict) -> bool:
@@ -134,6 +122,25 @@ def is_frontend_format(data: dict) -> bool:
     return False
 
 
+# =============================================================================
+# GRAPH HELPERS
+# =============================================================================
+
+def _apply_params_to_graph(graph: Graph, params: EvaluationParams) -> Graph:
+    """
+    Return a new Graph with directed/weighted/multigraph copied from EvaluationParams.
+    This is the single place where these flags are stamped onto a graph object —
+    they must never come from the student or teacher payload.
+    """
+    return Graph(
+        nodes=graph.nodes,
+        edges=graph.edges,
+        directed=params.directed,
+        weighted=params.weighted,
+        multigraph=params.multigraph,
+    )
+
+
 # =============================================================================
 # FEEDBACK GENERATION HELPERS
 # =============================================================================
@@ -615,59 +622,57 @@ def _ok() -> Result:
     def _err(msg: str) -> Result:
         return Result(is_correct=False, feedback_items=[("error", msg)])
 
-    # ── parse & validate inputs ──────────────────────────────────────────
+    # ── parse params FIRST — directed/weighted/multigraph live here ─────
+
+    raw_params = _to_dictish(params) or {}
+    try:
+        p = EvaluationParams.model_validate(raw_params)
+    except ValidationError as e:
+        return _err(
+            "Invalid params schema. Expected e.g. "
+            "{'evaluation_type': 'connectivity'|'bipartite'|'graph_coloring'|...}. "
+            f"Error: {e}"
+        )
+
+    # ── parse response (student's graph) ─────────────────────────────────
 
-    # Parse response (student's graph)
     response_dict = _to_dictish(response) or {}
-    
-    # Check if response contains frontend pipe-delimited format and convert
+
     if is_frontend_format(response_dict):
         parsed_graph = parse_frontend_graph(response_dict)
-        response_dict = {"graph": parsed_graph}
-    
+        response_dict = {"graph": parsed_graph.model_dump()}
+
     try:
         resp = Response.model_validate(response_dict)
     except ValidationError as e:
         return _err(f"Invalid response schema: {e}")
 
-    # Parse answer (teacher's reference)
+    # ── parse answer (teacher's reference) ───────────────────────────────
+
     answer_dict = _to_dictish(answer) or {}
-    
-    # Check if answer contains frontend pipe-delimited format and convert
+
     if is_frontend_format(answer_dict):
         parsed_graph = parse_frontend_graph(answer_dict)
-        answer_dict = {"graph": parsed_graph}
-    
+        answer_dict = {"graph": parsed_graph.model_dump()}
+
     try:
         ans = Answer.model_validate(answer_dict)
     except ValidationError as e:
         return _err(f"Invalid answer schema: {e}")
 
-    raw_params = _to_dictish(params) or {}
-    try:
-        p = EvaluationParams.model_validate(raw_params)
-    except ValidationError as e:
-        return _err(
-            "Invalid params schema. Expected e.g. "
-            "{'evaluation_type': 'connectivity'|'bipartite'|'graph_coloring'|...}. "
-            f"Error: {e}"
-            f"response: {response}"
-            f"response_dict: {response_dict}"
-            f"answer: {answer}"
-            f"answer_dict: {answer_dict}"
-            f"params: {params}"
-            f"raw_params: {raw_params}"
-        )
+    # ── resolve graphs and stamp params flags ─────────────────────────────
+    # directed/weighted/multigraph come exclusively from params — never from
+    # the student or teacher payload.
 
-    # ── resolve graphs ───────────────────────────────────────────────────
-    # student_graph (resp.graph) is always present — the student submits a graph.
-    # ans.graph is only present for isomorphism / subgraph checks where the
-    # teacher provides a reference graph.  For all other eval types the teacher
-    # sets the expected property value directly in the answer (e.g. ans.is_connected).
     student_graph: Graph = resp.graph
     if student_graph is None:
         return _err("response.graph is required — the student must submit a graph.")
 
+    student_graph = _apply_params_to_graph(student_graph, p)
+
+    if ans.graph is not None:
+        ans = ans.model_copy(update={"graph": _apply_params_to_graph(ans.graph, p)})
+
     # ── helper: grade a simple boolean property ──────────────────────────
     def _grade_bool(
         label: str,

evaluation_function/schemas/graph.py

@@ -32,9 +32,12 @@ class Config:
 class Graph(BaseModel):
     nodes: list[Node] = Field(..., description="List of nodes in the graph")
     edges: list[Edge] = Field(default_factory=list, description="List of edges")
-    directed: bool = Field(False, description="Whether the graph is directed")
-    weighted: bool = Field(False, description="Whether the graph is weighted (metadata only, not used in evaluation)")
-    multigraph: bool = Field(False, description="Whether the graph allows multiple edges (metadata only, not used in evaluation)")
+    # These flags are NOT part of the student/teacher payload schema.
+    # They are set exclusively from EvaluationParams by _apply_params_to_graph()
+    # at evaluation time so that algorithm functions can read them.
+    directed: bool = Field(False, description="Set from EvaluationParams.directed at evaluation time — do not include in response/answer payloads")
+    weighted: bool = Field(False, description="Set from EvaluationParams.weighted at evaluation time — do not include in response/answer payloads")
+    multigraph: bool = Field(False, description="Set from EvaluationParams.multigraph at evaluation time — do not include in response/answer payloads")
 
     class Config:
         extra = "allow"

evaluation_function/schemas/params.py

@@ -75,6 +75,11 @@ class TraversalParams(BaseModel):
 class EvaluationParams(BaseModel):
     evaluation_type: EvaluationType = Field(..., description="The type of evaluation to perform")
 
+    # Graph structure flags — sourced from params, not from the response/answer graph payload
+    directed: bool = Field(False, description="Whether the graph is directed")
+    weighted: bool = Field(False, description="Whether the graph is weighted")
+    multigraph: bool = Field(False, description="Whether the graph allows multiple edges")
+
     connectivity: Optional[ConnectivityParams] = None
     bipartite: Optional[BipartiteParams] = None
     graph_coloring: Optional[GraphColoringParams] = None

tests/test_evaluation_function_core.py

@@ -18,12 +18,12 @@
 
 # ── helpers ──────────────────────────────────────────────────────────────
 
-def _graph(nodes, edges, *, directed=False):
+def _graph(nodes, edges):
+    """Build a plain graph dict with only nodes and edges — no graph-level flags."""
     return {
         "nodes": [{"id": n} for n in nodes],
         "edges": [{"source": s, "target": t, **({"weight": w} if (w := e.get("weight")) is not None else {})}
                   for e in edges for s, t in [(e["source"], e["target"])]],
-        "directed": directed,
     }
 
 
@@ -53,15 +53,15 @@ def test_disconnected(self):
         assert r["is_correct"] is True
 
     def test_strongly_connected(self):
-        g = _graph(["A", "B"], [{"source": "A", "target": "B"}, {"source": "B", "target": "A"}], directed=True)
+        g = _graph(["A", "B"], [{"source": "A", "target": "B"}, {"source": "B", "target": "A"}])
         r = _eval({"graph": g}, {"is_connected": True},
-                  {"evaluation_type": "connectivity", "connectivity": {"check_type": "strongly_connected"}})
+                  {"evaluation_type": "connectivity", "directed": True, "connectivity": {"check_type": "strongly_connected"}})
         assert r["is_correct"] is True
 
     def test_weakly_connected(self):
-        g = _graph(["A", "B"], [{"source": "A", "target": "B"}], directed=True)
+        g = _graph(["A", "B"], [{"source": "A", "target": "B"}])
         r = _eval({"graph": g}, {"is_connected": True},
-                  {"evaluation_type": "connectivity", "connectivity": {"check_type": "weakly_connected"}})
+                  {"evaluation_type": "connectivity", "directed": True, "connectivity": {"check_type": "weakly_connected"}})
         assert r["is_correct"] is True
 
     def test_missing_expected_value(self):
@@ -144,17 +144,17 @@ def test_wrong_cycle_answer(self):
     def test_directed_cycle(self):
         g = _graph(["A", "B", "C"], [
             {"source": "A", "target": "B"}, {"source": "B", "target": "C"}, {"source": "C", "target": "A"}
-        ], directed=True)
+        ])
         r = _eval({"graph": g}, {"has_cycle": True},
-                  {"evaluation_type": "cycle_detection"})
+                  {"evaluation_type": "cycle_detection", "directed": True})
         assert r["is_correct"] is True
 
     def test_directed_dag(self):
         g = _graph(["A", "B", "C"], [
             {"source": "A", "target": "B"}, {"source": "A", "target": "C"}
-        ], directed=True)
+        ])
         r = _eval({"graph": g}, {"has_cycle": False},
-                  {"evaluation_type": "cycle_detection"})
+                  {"evaluation_type": "cycle_detection", "directed": True})
         assert r["is_correct"] is True
 
 
@@ -341,15 +341,15 @@ class TestDAG:
     def test_dag_correct(self):
         g = _graph(["A", "B", "C"], [
             {"source": "A", "target": "B"}, {"source": "A", "target": "C"}
-        ], directed=True)
-        r = _eval({"graph": g}, {"is_dag": True}, {"evaluation_type": "dag"})
+        ])
+        r = _eval({"graph": g}, {"is_dag": True}, {"evaluation_type": "dag", "directed": True})
         assert r["is_correct"] is True
 
     def test_not_dag_has_cycle(self):
         g = _graph(["A", "B"], [
             {"source": "A", "target": "B"}, {"source": "B", "target": "A"}
-        ], directed=True)
-        r = _eval({"graph": g}, {"is_dag": False}, {"evaluation_type": "dag"})
+        ])
+        r = _eval({"graph": g}, {"is_dag": False}, {"evaluation_type": "dag", "directed": True})
         assert r["is_correct"] is True
 
     def test_undirected_never_dag(self):