course peer grading: parse and enter grades student grades

Author: williamstein

src/packages/frontend/course/actions.ts

@@ -266,11 +266,11 @@ export class CourseActions extends Actions<CourseState> {
   }
 
   // ACTIVITY ACTIONS
-  public set_activity(
+  public set_activity = (
     opts: { id: number; desc?: string } | { id?: number; desc: string },
-  ): number {
+  ): number => {
     return this.activity.set_activity(opts);
-  }
+  };
 
   public clear_activity(id?: number): void {
     this.activity.clear_activity(id);

src/packages/frontend/course/assignments/actions.ts

@@ -65,8 +65,10 @@ import {
   NBGRADER_MAX_OUTPUT,
   NBGRADER_MAX_OUTPUT_PER_CELL,
   NBGRADER_TIMEOUT_MS,
-  PEER_GRADING_GUIDE_FN,
+  PEER_GRADING_GUIDE_FILENAME,
   STUDENT_SUBDIR,
+  PEER_GRADING_GUIDELINES_GRADE_MARKER,
+  PEER_GRADING_GUIDELINES_COMMENT_MARKER,
 } from "./consts";
 
 export class AssignmentsActions {
@@ -891,10 +893,10 @@ ${details}
     });
     this.course_actions.student_projects.action_all_student_projects("start");
     // We request to start all projects simultaneously, and the system
-    // will start doing that.  I think it's no so much important that
+    // will start doing that.  I think it's not so much important that
     // the projects are actually running, but that they were started
     // before the copy operations started.
-    await delay(15 * 1000);
+    await delay(5 * 1000);
     this.course_actions.clear_activity(id);
   }
 
@@ -948,8 +950,120 @@ ${details}
       desc,
       short_desc,
     );
+    await this.peerParseStudentGrading(assignment_id);
   }
 
+  private peerParseStudentGrading = async (assignment_id: string) => {
+    // For each student do the following:
+    //   If they already have a recorded grade, do nothing further.
+    //   If they do not have a recorded grade, load all of the
+    //   PEER_GRADING_GUIDE_FILENAME files that were collected
+    //   from the students, then create a grade from that (if possible), along
+    //   with a comment that explains how that grade was obtained, without
+    //   saying which student did what.
+    const { store, assignment } = this.course_actions.resolve({
+      assignment_id,
+    });
+    if (assignment == null) {
+      throw Error("no such assignment");
+    }
+    const id = this.course_actions.set_activity({
+      desc: "Parsing peer grading",
+    });
+    const allGrades = assignment.get("grades", Map()).toJS() as {
+      [student_id: string]: string;
+    };
+    const allComments = assignment.get("comments", Map()).toJS() as {
+      [student_id: string]: string;
+    };
+    // compute missing grades
+    for (const student_id of store.get_student_ids()) {
+      if (allGrades[student_id]) {
+        // a grade is already set
+        continue;
+      }
+      // attempt to compute a grade
+      const peer_student_ids: string[] = store.get_peers_that_graded_student(
+        assignment_id,
+        student_id,
+      );
+      const course_project_id = store.get("course_project_id");
+      const grades: number[] = [];
+      let comments: string[] = [];
+      const student_name = store.get_student_name(student_id);
+      this.course_actions.set_activity({
+        id,
+        desc: `Parsing peer grading of ${student_name}`,
+      });
+      for (const peer_student_id of peer_student_ids) {
+        const path = join(
+          `${assignment.get("collect_path")}-peer-grade`,
+          student_id,
+          peer_student_id,
+          PEER_GRADING_GUIDE_FILENAME,
+        );
+        try {
+          const contents = await webapp_client.project_client.read_text_file({
+            project_id: course_project_id,
+            path,
+          });
+          const i = contents.lastIndexOf(PEER_GRADING_GUIDELINES_GRADE_MARKER);
+          if (i == -1) {
+            continue;
+          }
+          let j = contents.lastIndexOf(PEER_GRADING_GUIDELINES_COMMENT_MARKER);
+          if (j == -1) {
+            j = contents.length;
+          }
+          const grade = parseFloat(
+            contents
+              .slice(i + PEER_GRADING_GUIDELINES_GRADE_MARKER.length, j)
+              .trim(),
+          );
+          if (!isFinite(grade) && isNaN(grade)) {
+            continue;
+          }
+          const comment = contents.slice(
+            j + PEER_GRADING_GUIDELINES_COMMENT_MARKER.length,
+          );
+          grades.push(grade);
+          comments.push(comment);
+        } catch (err) {
+          // grade not available for some reason
+          console.warn("issue reading peer grading file", {
+            path,
+            err,
+            student_name,
+          });
+        }
+      }
+      if (grades.length > 0) {
+        const grade = grades.reduce((a, b) => a + b) / grades.length;
+        allGrades[student_id] = `${grade}`;
+        if (!allComments[student_id]) {
+          const studentComments = comments
+            .filter((x) => x.trim())
+            .map((x) => `- ${x}`)
+            .join("\n\n");
+          allComments[student_id] = `Grades: ${grades.join(", ")}\n\n${
+            studentComments ? "Student Comments:\n" + studentComments : ""
+          }`;
+        }
+      }
+    }
+    // set them in the course data
+    this.course_actions.set(
+      {
+        table: "assignments",
+        assignment_id,
+        grades: allGrades,
+        comments: allComments,
+      },
+      true,
+    );
+    this.course_actions.clear_activity(id);
+  };
+
   private async assignment_action_all_students(
     assignment_id: string,
     new_only: boolean,
@@ -1094,7 +1208,7 @@ ${details}
       // write instructions file for the student, where they enter the grade,
       // and also it tells them what to do.
       await this.write_text_file_to_course_project({
-        path: join(src_path, PEER_GRADING_GUIDE_FN),
+        path: join(src_path, PEER_GRADING_GUIDE_FILENAME),
         content: guidelines,
       });
       const target_path = join(target_base_path, peer_student_id);
@@ -1125,10 +1239,10 @@ ${details}
 
   // Collect all the peer graading of the given student (not the work the student did, but
   // the grading about the student!).
-  private async peer_collect_from_student(
+  private peer_collect_from_student = async (
     assignment_id: string,
     student_id: string,
-  ): Promise<void> {
+  ): Promise<void> => {
     if (this.start_copy(assignment_id, student_id, "last_peer_collect")) {
       return;
     }
@@ -1215,7 +1329,7 @@ ${details}
     } catch (err) {
       finish(err);
     }
-  }
+  };
 
   // This doesn't really stop it yet, since that's not supported by the backend.
   // It does stop the spinner and let the user try to restart the copy.

src/packages/frontend/course/assignments/configure-peer.tsx

@@ -17,26 +17,11 @@ import { server_days_ago } from "@cocalc/util/misc";
 import { Button, Card, Col, InputNumber, Row, Switch, Typography } from "antd";
 import { CourseActions } from "../actions";
 import { AssignmentRecord } from "../store";
-import { PEER_GRADING_GUIDE_FN } from "./consts";
-
-// everything from GRADING_GUIDELINES_GRADE_MARKER to GRADING_GUIDELINES_COMMENT_MARKER
-// is parsed as a numerical grade, if possible.  i18n's don't mess this up!  Also,
-// changing this would break outstanding assignments, so change with caution.
-const GRADING_GUIDELINES_GRADE_MARKER = "OVERALL GRADE (A SINGLE NUMBER):";
-const GRADING_GUIDELINES_COMMENT_MARKER = "COMMENTS ABOUT GRADE:";
-
-const DEFAULT_GUIDELINES = `
-Put your final overall score below after "${GRADING_GUIDELINES_GRADE_MARKER}"
-
-
-
-${GRADING_GUIDELINES_GRADE_MARKER}
-
-
-
-${GRADING_GUIDELINES_COMMENT_MARKER}
-
-`;
+import {
+  PEER_GRADING_GUIDE_FILENAME,
+  PEER_GRADING_GUIDELINES_GRADE_MARKER,
+  PEER_GRADING_DEFAULT_GUIDELINES,
+} from "./consts";
 
 interface Props {
   assignment: AssignmentRecord;
@@ -78,8 +63,8 @@ export const ConfigurePeerGrading: React.FC<Props> = React.memo(
     }
 
     function set_peer_grade(config) {
-      if (config.enabled && !config.guidelines) {
-        config.guidelines = DEFAULT_GUIDELINES;
+      if (config.enabled && !config.guidelines?.trim()) {
+        config.guidelines = PEER_GRADING_DEFAULT_GUIDELINES;
       }
       actions.assignments.set_peer_grade(
         assignment.get("assignment_id"),
@@ -152,15 +137,15 @@ export const ConfigurePeerGrading: React.FC<Props> = React.memo(
               Grading guidelines:{" "}
               <Typography.Text type={"secondary"}>
                 This text will be made available to students in their grading
-                folder in a file <code>{PEER_GRADING_GUIDE_FN}</code>. Tell your
-                students how to grade each problem. Since this is a markdown
-                file, you might also provide a link to a publicly shared file or
-                directory with additional guidelines. If you keep the default "
-                {GRADING_GUIDELINES_GRADE_MARKER}" text, then the grade the
-                student puts after that will be parsed from the file and made
-                available to you in the user interface, and it can impact the
-                default grade assigned to the student (e.g., if it is numerical,
-                then the average is assigned).
+                folder in a file <code>{PEER_GRADING_GUIDE_FILENAME}</code>.
+                Tell your students how to grade each problem. Since this is a
+                markdown file, you might also provide a link to a publicly
+                shared file or directory with additional guidelines. If you keep
+                the default "{PEER_GRADING_GUIDELINES_GRADE_MARKER}" text, then
+                the grade the student puts after that will be parsed from the
+                file and the default grade assigned to the student will be the
+                average of the peer grades. You can edit the grade before
+                returning the graded assignment to the student.
               </Typography.Text>
             </Typography.Paragraph>
           </Col>

src/packages/frontend/course/assignments/consts.ts

@@ -16,4 +16,30 @@ export const NBGRADER_MAX_OUTPUT_PER_CELL: number = 500000;
 export const NBGRADER_MAX_OUTPUT: number = 4000000;
 
 // filename of the peer grading guide
-export const PEER_GRADING_GUIDE_FN = "GRADING-GUIDE.md";
+export const PEER_GRADING_GUIDE_FILENAME = "GRADING-GUIDE.md";
+
+// Everything from GRADING_GUIDELINES_GRADE_MARKER to GRADING_GUIDELINES_COMMENT_MARKER
+// is parsed as a numerical grade, if possible.  i18n's don't mess this up!  Also,
+// changing this would break outstanding assignments, so change with caution.  
+// A fix
+// would be to store these strings somewhere when pushing the assignment out, so that
+// the same ones are used when collecting and parsing.    But that will take a few hours
+// more work, and it is only necessary if we decide to change these. Whoever decides
+// to change these has to do that work.
+export const PEER_GRADING_GUIDELINES_GRADE_MARKER =
+  "OVERALL GRADE (a single number):";
+export const PEER_GRADING_GUIDELINES_COMMENT_MARKER =
+  "COMMENTS ABOUT GRADE (student will see, but not who made them):";
+
+export const PEER_GRADING_DEFAULT_GUIDELINES = `
+Put your final overall score below after "${PEER_GRADING_GUIDELINES_GRADE_MARKER}"
+
+
+
+${PEER_GRADING_GUIDELINES_GRADE_MARKER}
+
+
+
+${PEER_GRADING_GUIDELINES_COMMENT_MARKER}
+
+`;

src/packages/frontend/frame-editors/course-editor/course-panel-wrapper.tsx

@@ -182,7 +182,9 @@ const CoursePanelWrapper: React.FC<FrameProps> = React.memo(
           trunc={80}
           on_clear={() => {
             const actions = redux.getActions(name) as CourseActions;
-            if (actions != null) actions.clear_activity();
+            if (actions != null) {
+              actions.clear_activity();
+            }
           }}
         />
       );