Repo init

README.md

@@ -1,32 +1,24 @@
 ---
+task_categories:
+- text-generation
+language:
+- en
+tags:
+- code
+size_categories:
+- 100K<n<1M
 configs:
-- config_name: 2024
+- config_name: 2024-1
   data_files: 
-  - split: evaluation
-    path: "data/v1_bea/evaluation_dataset-*.csv"
-  - split: final_dataset
-    path: "data/v1_bea/final_dataset-*.csv"
-  - split: manual_evaluation
-    path: "data/v1_bea/manual_evaluation_dialogues-*.csv"
-- config_name: v2_sigcse
-  data_files: 
-  - split: train
-    path: "data/v2_sigcse/train-*.csv"
-  - split: evaluation
-    path: "data/v2_sigcse/evaluation_dataset-*.csv"
-  - split: final_dataset
-    path: "data/v2_sigcse/final_dataset-*.csv"
-  - split: manual_evaluation
-    path: "data/v2_sigcse/manual_evaluation_dialogues-*.csv"
-  - split: testset
-    path: "data/v2_sigcse/testset-*.csv"
-- config_name: v3
-  data_files: 
-  - split: final_dataset
-    path: "data/v3/final_dataset-*.csv"
-  - split: testset
-    path: "data/v3/testset-*.csv"
+  - split: assessment
+    path: data/2024-1/assessment*.csv
+  - split: execution
+    path: data/2024-1/execution*.csv
+  - split: grade
+    path: data/2024-1/grade*.csv
+  default: true
 ---
 
+
 # CodeBench dataset
 

data/2024-1/assessment_2024-1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:533cb2f8227895beeb0313cea518db9d5c362e0986c73b78dc35d46b237303e1
+size 58424

data/2024-1/execution_2024-1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fd97ab5c1455baf0b77e2c800522481a63b9c0e464095f45586d4068bdeb159b
+size 1974098

data/2024-1/grade_2024-1.csv

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:66b8b3486c0f8b9429239d73146c1f0b1b43c15594223604934baad58148e3b6
+size 180450

src/assessment.py

@@ -0,0 +1,69 @@
+import pandas as pd
+from src.utils import read_data_file
+
+def parse_assessment_simple(full_path: str) -> pd.DataFrame:
+    """
+    Minimal parser:
+    - Split per line
+    - For lines starting with '----', strip it, then split on the first ':'
+    - Build a flat dict, then move keys like 'exercise 01' into an 'exercises' dict
+    - Return a one-row DataFrame
+    """
+
+    print(f"Parsing assessment data from {full_path}...")
+    
+    assessment_number = int(full_path.split("/")[-1].replace(".data", ""))
+    text = read_data_file(full_path)
+
+    lines = [ln.strip() for ln in text.strip().splitlines()]
+    flat = {}
+
+    for ln in lines:
+        if not ln or ln.startswith("-- ASSESSMENT DATA") or ln.startswith("-- EXERCISES"):
+            continue
+        if ln.startswith("----"):
+            # drop leading dashes and spaces
+            core = ln.lstrip("-").strip()
+            if ":" not in core:
+                continue
+            k, v = core.split(":", 1)
+            k = k.strip().lower()                     # normalize a bit
+            v = v.strip()
+            flat[k] = v
+
+    # Extract exercises into a nested dict
+    exercises = {}
+    for k in list(flat.keys()):
+        if k.startswith("exercise "):
+            # 'exercise 01' -> 1
+            try:
+                idx = int(k.split()[1])
+            except Exception:
+                continue
+            try:
+                exercises[idx] = int(flat[k])
+            except Exception:
+                # keep as string if not an int
+                exercises[idx] = flat[k]
+            del flat[k]
+
+    # Optional light cleanup: turn common numerics into numbers
+    def to_int(x):
+        try: return int(x)
+        except: return x
+    def to_float(x):
+        try: return float(x)
+        except: return x
+
+    for key in ("class number", "total_exercises"):
+        if key in flat:
+            flat[key] = to_int(flat[key])
+    if "weight" in flat:
+        flat["weight"] = to_float(flat["weight"])
+
+    # Rename keys to snake_case (purely cosmetic)
+    snake = {k.replace(" ", "_"): v for k, v in flat.items()}
+    snake["exercises"] = exercises or None
+    snake["assessment_id"] = assessment_number
+    
+    return pd.DataFrame([snake])

src/execution.py

@@ -0,0 +1,227 @@
+import pandas as pd
+from src.utils import read_data_file
+
+SEP = "*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*"
+
+def split_execution_traces(log_text: str):
+    parts = log_text.strip().split(SEP)
+    return [p.strip() for p in parts if p.strip()]
+
+def _extract_code(block: str):
+    lines = block.splitlines()
+    start_idx = None
+    for i, ln in enumerate(lines):
+        if ln.strip().lower().startswith("-- code:"):
+            start_idx = i + 1
+            break
+    if start_idx is None:
+        return None, None  # (code_text, code_end_idx)
+
+    end_idx = len(lines)
+    for j in range(start_idx, len(lines)):
+        s = lines[j].strip()
+        if s.startswith("-- ") and s.endswith(":"):
+            end_idx = j
+            break
+    code_block = "\n".join(lines[start_idx:end_idx]).strip("\n")
+    return (code_block if code_block.strip() else None), end_idx
+
+def _extract_test_output(block: str):
+    lines = block.splitlines()
+    _, after_code_idx = _extract_code(block)
+    if after_code_idx is None:
+        return None, None
+
+    section_idx = None
+    section_tag = None
+    for k in range(after_code_idx, len(lines)):
+        tag = lines[k].strip().lower()
+        if tag.startswith("-- output:") or tag.startswith("-- error:"):
+            section_idx = k
+            section_tag = tag
+            break
+    if section_idx is None:
+        return None, None
+
+    end_idx = len(lines)
+    for t in range(section_idx + 1, len(lines)):
+        s = lines[t].strip()
+        if s.startswith("-- ") and s.endswith(":"):
+            end_idx = t
+            break
+
+    content = "\n".join(lines[section_idx + 1 : end_idx]).strip("\n")
+    if not content.strip():
+        content = None
+
+    out_type = "stdout" if section_tag.startswith("-- output:") else "stderr"
+    return out_type, content
+
+def _read_scalar_after_section(lines, idx):
+    """Return the first non-empty line after lines[idx], or None."""
+    for j in range(idx + 1, len(lines)):
+        txt = lines[j].strip()
+        if not txt:
+            # allow empty line(s) before the scalar
+            continue
+        return txt
+    return None
+
+def _extract_submission(block: str):
+    """
+    Extract from a SUBMISSION/SUBMITION block:
+      - execution_time (float, seconds)
+      - grade (float, percent 0..100)
+      - testcases (list of dicts with index, input, correct_output, user_output)
+    """
+    lines = block.splitlines()
+    # 1) Find where code ends to start scanning the sections after it
+    _, after_code_idx = _extract_code(block)
+    scan_start = after_code_idx if after_code_idx is not None else 0
+
+    execution_time = None
+    grade = None
+    testcases = []
+
+    i = scan_start
+    while i < len(lines):
+        raw = lines[i].strip()
+        low = raw.lower()
+
+        # -- EXECUTION TIME:
+        if low.startswith("-- execution time:"):
+            val = _read_scalar_after_section(lines, i)
+            if val is not None:
+                # parse float; ignore parse errors silently
+                try:
+                    execution_time = float(val)
+                except:
+                    pass
+            i += 1
+            continue
+
+        # -- TEST CASE N:
+        if low.startswith("-- test case"):
+            # parse index between "test case " and ":"
+            idx = None
+            try:
+                # e.g., "-- TEST CASE 3:"
+                head = raw.split(":", 1)[0]
+                idx = int(head.lower().split("test case", 1)[1].strip())
+            except:
+                pass
+
+            # collect subfields until next '-- TEST CASE' or '-- GRADE:' or end
+            j = i + 1
+            current = {"index": idx, "input": "", "correct_output": "", "user_output": ""}
+            active = None  # "input" | "correct_output" | "user_output"
+
+            while j < len(lines):
+                sraw = lines[j].rstrip("\n")
+                slow = sraw.strip().lower()
+
+                if slow.startswith("-- test case") or slow.startswith("-- grade:"):
+                    break  # end of this test case section
+
+                if slow.startswith("---- input:"):
+                    active = "input"
+                    # reset to collect fresh content for this field
+                    current["input"] = ""
+                elif slow.startswith("---- correct output:"):
+                    active = "correct_output"
+                    current["correct_output"] = ""
+                elif slow.startswith("---- user output:"):
+                    active = "user_output"
+                    current["user_output"] = ""
+                else:
+                    if active:
+                        # preserve newlines as in the log
+                        current[active] += (sraw + "\n")
+                j += 1
+
+            # strip trailing newlines
+            for k in ("input", "correct_output", "user_output"):
+                current[k] = current[k].rstrip("\n")
+
+            testcases.append(current)
+            i = j
+            continue
+
+        # -- GRADE:
+        if low.startswith("-- grade:"):
+            val = _read_scalar_after_section(lines, i)
+            if val is not None:
+                v = val.strip().rstrip("%").strip()
+                try:
+                    grade = float(v)
+                except:
+                    pass
+            i += 1
+            continue
+
+        i += 1
+
+    return execution_time, grade, testcases
+
+def parse_execution_data(full_path):
+    """
+    Returns one row per trace with:
+      user, class_number, type, timestamp, code,
+      output_type, output_content (for TEST),
+      execution_time, grade, testcases (for SUBMISSION/SUBMITION),
+      trace
+    """
+
+    print(f"Parsing execution data from {full_path}...")
+    
+    user = full_path.split("/")[-3]
+    class_number = full_path.split("/")[-5]
+    assessment_id, exercise_id = full_path.split("/")[-1].replace(".log", "").split("_")
+    assessment_id = int(assessment_id)
+    exercise_id = int(exercise_id)
+
+    log_text = read_data_file(full_path)  # you provide this
+
+    rows = []
+    for block in split_execution_traces(log_text):
+        # header '== TYPE (timestamp)'
+        first = next((ln.strip() for ln in block.splitlines() if ln.strip()), "")
+        header = first.lstrip("=").strip()
+
+        typ, ts = None, None
+        if "(" in header and ")" in header:
+            left, rest = header.split("(", 1)
+            typ = left.strip()
+            ts = rest.split(")", 1)[0].strip()
+        else:
+            typ = header
+
+        code, _ = _extract_code(block)
+
+        # Defaults
+        output_type, output_content = None, None
+        execution_time, grade, testcases = None, None, None
+
+        tnorm = (typ or "").strip().lower()
+        if tnorm == "test":
+            output_type, output_content = _extract_test_output(block)
+        elif tnorm in ("submission", "submition", "submit"):
+            execution_time, grade, testcases = _extract_submission(block)
+
+        rows.append({
+            "user":           user,
+            "class_number":   class_number,
+            "assessment_id":  assessment_id,
+            "exercise_id":    exercise_id,
+            "type":           typ,
+            "timestamp":      ts,
+            "code":           code,
+            "output_type":    output_type,
+            "output_content": output_content,
+            "execution_time": execution_time,
+            "grade":          grade,            # percent 0..100
+            "testcases":      testcases,        # list[dict] or None
+            "trace":          block
+        })
+
+    return pd.DataFrame(rows)

src/grade.py

@@ -0,0 +1,107 @@
+import pandas as pd
+from src.utils import read_data_file 
+
+def parse_grade_data(full_path: str) -> pd.DataFrame:
+    """
+    Parse a simple grade block like:
+        ---- grade (0-10): 0
+        ---- number of exercises: 4
+        ---- correct: 0
+        ---- incorrect: 1
+        ---- blank: 3
+    Returns a one-row DataFrame with:
+        grade, grade_min, grade_max, number_of_exercises, correct, incorrect, blank
+    """
+
+    assessment_number = int(full_path.split("/")[-1].replace(".log", ""))
+    user = full_path.split("/")[-3]
+    class_number = full_path.split("/")[-5]
+    text = read_data_file(full_path)
+
+    lines = [ln.strip() for ln in text.strip().splitlines() if ln.strip()]
+    flat = {}
+
+    for ln in lines:
+        if not ln.startswith("----"):
+            continue
+        core = ln.lstrip("-").strip()
+        if ":" not in core:
+            continue
+        k, v = core.split(":", 1)
+        k = k.strip().lower()
+        v = v.strip()
+        flat[k] = v
+
+    # Extract grade and grade range if present in key "grade (x-y)"
+    grade_min, grade_max = None, None
+    grade_val = None
+
+    # Find the grade key (it may look like 'grade (0-10)' or 'grade (0 - 10)')
+    grade_key = next((k for k in flat.keys() if k.startswith("grade")), None)
+    if grade_key is not None:
+        # value is after ':', convert to int/float if possible
+        try:
+            grade_val = float(flat[grade_key])
+            if grade_val.is_integer():
+                grade_val = int(grade_val)
+        except:
+            grade_val = flat[grade_key]
+
+        # parse range in parentheses in the key
+        if "(" in grade_key and ")" in grade_key:
+            inside = grade_key.split("(", 1)[1].split(")", 1)[0]  # e.g., "0-10" or "0 - 10"
+            # normalize "0 - 10" -> "0-10"
+            inside = inside.replace(" ", "")
+            if "-" in inside:
+                lo, hi = inside.split("-", 1)
+                try:
+                    grade_min = float(lo)
+                    grade_max = float(hi)
+                    if grade_min.is_integer(): grade_min = int(grade_min)
+                    if grade_max.is_integer(): grade_max = int(grade_max)
+                except:
+                    pass
+
+        # remove original grade key from flat
+        del flat[grade_key]
+
+    # Coerce remaining known numeric fields
+    def to_num(x):
+        try:
+            y = float(x)
+            return int(y) if y.is_integer() else y
+        except:
+            return x
+
+    rename_map = {
+        "number of exercises": "number_of_exercises",
+        "correct": "correct",
+        "incorrect": "incorrect",
+        "blank": "blank",
+    }
+    out = {}
+    for src, dst in rename_map.items():
+        if src in flat:
+            out[dst] = to_num(flat[src])
+
+    out["grade"] = grade_val
+    out["grade_min"] = grade_min
+    out["grade_max"] = grade_max
+    out["class_number"] = class_number
+    out["assessment_number"] = assessment_number
+    out["user"] = user
+    
+    return pd.DataFrame([out])
+
+def parse_final_grade_data(full_path):
+    user = full_path.split("/")[-3]
+    class_number = full_path.split("/")[-5]
+    text = read_data_file(full_path)
+
+    out = {}
+    out["class_number"] = class_number
+    out["assessment_number"] = -1
+    out["user"] = user
+    out["grade"] = text 
+    return pd.DataFrame([out])
+    

src/process.py

@@ -0,0 +1,69 @@
+
+import os
+import pandas as pd
+from argparse import ArgumentParser
+
+from src.grade import parse_grade_data, parse_final_grade_data
+from src.execution import parse_execution_data
+from src.assessment import parse_assessment_simple
+
+def parse_args():
+    """
+    Parse command line arguments.
+    """
+    parser = ArgumentParser(description="Process CodeBench data.")
+    parser.add_argument("--input", type=str, required=True, help="Input directory containing downloaded tar.")
+    return parser.parse_args()
+
+
+def process_data(BASE_PATH):
+
+    assessment_data = []
+    grade_data = []
+    execution_data = []
+    for root, dirs, files in os.walk(BASE_PATH):
+        for d in dirs:
+            full_path = os.path.join(root, d)
+        if not len(dirs):
+            # We are within a last level directory
+            if root.split("/")[-1] == "assessments":
+                for f in files:
+                    full_path = os.path.join(root, f)
+                    assessment_data.append(parse_assessment_simple(full_path))
+            elif root.split("/")[-1] == "grades":
+                for f in files:
+                    if f.endswith(".data"): # Final grade
+                        full_path = os.path.join(root, f)
+                        grade_data.append(parse_final_grade_data(full_path))
+                    else:
+                        full_path = os.path.join(root, f)
+                        grade_data.append(parse_grade_data(full_path)) 
+            elif root.split("/")[-1] == "executions":
+                for f in files:
+                    full_path = os.path.join(root, f)
+                    execution_data.append(parse_execution_data(full_path))
+                    break 
+
+    assessment_df = pd.concat(assessment_data)
+    grade_df = pd.concat(grade_data)
+    execution_df = pd.concat(execution_data)
+
+    return assessment_df, grade_df, execution_df
+
+def main():
+    args = parse_args()
+    # Load all provided dataframes
+    subset = args.input.split("/")[-1]
+    print(f"Processing data from {subset}...")
+    assessment_df, grade_df, execution_df = process_data(args.input)
+
+    # Save the dataframes to CSV files
+    base_save_path = f"./data/{subset}/"
+    os.makedirs(base_save_path, exist_ok=True)
+    assessment_df.to_csv(os.path.join(base_save_path, f"assessment_{subset}.csv"), index=False)
+    grade_df.to_csv(os.path.join(base_save_path, f"grade_{subset}.csv"), index=False)
+    execution_df.to_csv(os.path.join(base_save_path, f"execution_{subset}.csv"), index=False)
+
+
+if __name__ == "__main__":
+    main()

src/utils.py

@@ -0,0 +1,4 @@
+def read_data_file(path):
+    with open(path, "r") as fp:
+        content = fp.read()
+    return content