Datasets:
Download scripts/csv_to_jsonl.py from Eedi/Eedi-Misconceptions-Graph: direct link, hf CLI and curl.
- Browser
- Download file 12.4 kB
-
https://huggingface.co/datasets/Eedi/Eedi-Misconceptions-Graph/resolve/main/scripts/csv_to_jsonl.py
- Command line
-
hf download hf://datasets/Eedi/Eedi-Misconceptions-Graph/scripts/csv_to_jsonl.py
-
curl -L -o csv_to_jsonl.py https://huggingface.co/datasets/Eedi/Eedi-Misconceptions-Graph/resolve/main/scripts/csv_to_jsonl.py
12.4 kB
| #!/usr/bin/env python3 | |
| """ | |
| Convert the Eedi Misconceptions Graph CSV release (construct-map.csv / | |
| misconception-map.csv) into property-graph JSONL (nodes.jsonl / | |
| relationships.jsonl): one file of nodes, one file of relationships. | |
| Source: https://huggingface.co/datasets/Eedi/Eedi-Misconceptions-Graph (CC BY 4.0) | |
| Graph model | |
| ----------- | |
| (:Subject)-[:SUBJECT_CONTAINS_TOPIC]->(:Topic) | |
| (:Topic)-[:TOPIC_CONTAINS_SUBTOPIC]->(:SubTopic) | |
| (:SubTopic)-[:SUBTOPIC_CONTAINS_CONSTRUCT]->(:Construct) | |
| (:Construct)-[:CONSTRUCT_HAS_MISCONCEPTION {percentage}]->(:Misconception) | |
| Node ids are type-prefixed (eedi:construct:27) because Construct ids overlap | |
| with Subject/Topic/SubTopic ids. | |
| Usage | |
| ----- | |
| python csv_to_jsonl.py # write nodes.jsonl / relationships.jsonl next to this script | |
| python csv_to_jsonl.py --csv-dir my/csvs # use CSVs from somewhere else | |
| CSVs are read from ../data/ when this script sits in a clone of the Hugging Face | |
| repo (scripts/ next to data/); otherwise they're downloaded next to this script. | |
| Standard library only. | |
| """ | |
| # How this works, in one paragraph | |
| # -------------------------------- | |
| # The CSVs are "flat": every row repeats the whole Subject -> Topic -> SubTopic -> | |
| # Construct chain. A graph wants each of those things stored ONCE as a node, with | |
| # relationships joining them. So we walk every row, register each node/relationship | |
| # in a dictionary keyed by its id (a repeat of something already seen is simply a | |
| # no-op), and at the end write the de-duplicated contents out as JSONL. | |
| # | |
| # JSONL ("JSON Lines") = one complete JSON object per line. It streams well (no | |
| # need to parse one giant JSON array), and it's database-agnostic - Neo4j is just | |
| # one possible consumer. | |
| # | |
| # nodes.jsonl {"id": ..., "labels": [...], "properties": {...}} | |
| # relationships.jsonl {"type": ..., "startNodeId": ..., "endNodeId": ..., "properties": {...}} | |
| # Lets us write type hints like `dict | None` on older Pythons (3.8/3.9). | |
| from __future__ import annotations | |
| import argparse | |
| import csv | |
| import json | |
| import sys | |
| import urllib.request | |
| from collections import Counter | |
| from pathlib import Path | |
| # `resolve/{tag}` is Hugging Face's "raw file at this revision" URL. Pinning a tag | |
| # (rather than `main`) means the same command always gets the same data. | |
| CSV_URL = "https://huggingface.co/datasets/Eedi/Eedi-Misconceptions-Graph/resolve/{tag}/data/{name}" | |
| DEFAULT_TAG = "v1.0" | |
| CSV_NAMES = ("construct-map.csv", "misconception-map.csv") | |
| # Folder this script lives in - used as the default place to read/write files, so | |
| # the script behaves the same whichever directory you run it from. | |
| SCRIPT_DIR = Path(__file__).resolve().parent | |
| # In a clone of the Hugging Face repo the CSVs already sit in data/, beside scripts/. | |
| REPO_DATA_DIR = SCRIPT_DIR.parent / "data" | |
| # The curriculum tree, top to bottom. Each tuple says how to build one level: | |
| # (node label, CSV id column, id property name in the graph, CSV name column, parent label) | |
| # Both CSVs contain these same columns, so one table drives the hierarchy for both. | |
| # The graph property names are just the CSV column names in camelCase. | |
| HIERARCHY = [ | |
| ("Subject", "SubjectSubjectId", "subjectSubjectId", "SubjectName", None), | |
| ("Topic", "TopicSubjectId", "topicSubjectId", "TopicName", "Subject"), | |
| ("SubTopic", "SubTopicSubjectId", "subTopicSubjectId", "SubTopicName", "Topic"), | |
| ("Construct", "ConstructId", "constructId", "ConstructName", "SubTopic"), | |
| ] | |
| # Relationship type that points INTO each child level from its parent. | |
| CONTAINS = { | |
| "Topic": "SUBJECT_CONTAINS_TOPIC", | |
| "SubTopic": "TOPIC_CONTAINS_SUBTOPIC", | |
| "Construct": "SUBTOPIC_CONTAINS_CONSTRUCT", | |
| } | |
| def node_id(label: str, value: int) -> str: | |
| """Construct, 27 -> eedi:construct:27 | |
| Why prefix? The raw integer ids aren't unique across types. Subject/Topic/ | |
| SubTopic ids come from one SQL table, so they never clash with each other, | |
| but Construct ids are a separate sequence (e.g. 49 is both Subject | |
| 'Algebra' and Construct 'Find 10 less than a given number'). | |
| Strictly only Constructs need separating, but every type gets its own prefix | |
| anyway: one simple rule, ids that say what they are (eedi:topic:144), and no | |
| reliance on the shared-table guarantee holding in future versions.""" | |
| return f"eedi:{label.lower()}:{value}" | |
| def download(tag: str, dest: Path) -> None: | |
| """Fetch any CSV not already in `dest`. Existing files are reused, so delete | |
| them if you want a fresh copy (e.g. after changing --tag).""" | |
| dest.mkdir(parents=True, exist_ok=True) | |
| for name in CSV_NAMES: | |
| p = dest / name | |
| if not p.exists(): | |
| print(f"Downloading {name} ({tag}) ...") | |
| urllib.request.urlretrieve(CSV_URL.format(tag=tag, name=name), p) | |
| def default_csv_dir() -> Path: | |
| """Use the repo's data/ folder if both CSVs are there, else this script's folder | |
| (where download() will fetch them). Also used by load_eedi_graph.py.""" | |
| if all((REPO_DATA_DIR / name).is_file() for name in CSV_NAMES): | |
| return REPO_DATA_DIR | |
| return SCRIPT_DIR | |
| def read_csv(path: Path) -> list[dict]: | |
| """Read a CSV into a list of {column: value} dicts (all values are strings). | |
| newline="" - required by the csv module so quoted fields containing | |
| line breaks are handled correctly. | |
| encoding=utf-8-sig - plain UTF-8, but silently drops a byte-order mark if the | |
| file was saved by Excel (otherwise the first column name | |
| would come out as '\\ufeffSubjectName').""" | |
| with open(path, newline="", encoding="utf-8-sig") as f: | |
| return list(csv.DictReader(f)) | |
| class Graph: | |
| """Collects nodes/relationships, refusing conflicting duplicates. | |
| Everything is stored in dicts keyed by identity, so adding the same node or | |
| relationship twice is harmless - that's what de-duplicates the flat CSV rows. | |
| But if the "same" thing arrives with DIFFERENT content (e.g. construct 27 with | |
| two different names), we stop: that means the source data has changed shape | |
| and silently picking one version would hide the problem.""" | |
| def __init__(self): | |
| self.nodes: dict[str, dict] = {} # node id -> node record | |
| self.rels: dict[tuple, dict] = {} # (type, start id, end id) -> relationship record | |
| self.parent: dict[str, str] = {} # child node id -> parent node id (tree check) | |
| def add_node(self, label: str, id_prop: str, raw_id: str, name: str) -> str: | |
| """Register a node (if new) and return its id.""" | |
| value = int(raw_id.strip()) # CSV gives strings; store ids as integers in the graph | |
| nid = node_id(label, value) | |
| node = {"id": nid, "labels": [label], "properties": {id_prop: value, "name": name.strip()}} | |
| # setdefault: "insert `node` if nid is new; either way, give me what's stored". | |
| # So `existing` is either this node (first sighting) or the earlier one. | |
| existing = self.nodes.setdefault(nid, node) | |
| if existing != node: | |
| sys.exit(f"Conflicting definitions for {nid}:\n {existing}\n {node}") | |
| return nid | |
| def add_rel(self, rtype: str, start: str, end: str, props: dict | None = None) -> None: | |
| """Register a relationship (if new). Same setdefault trick as add_node. | |
| The key is (type, start, end), so there is at most one relationship of a | |
| given type between two nodes - matching MERGE semantics in the loader.""" | |
| key = (rtype, start, end) | |
| rel = {"type": rtype, "startNodeId": start, "endNodeId": end, "properties": props or {}} | |
| existing = self.rels.setdefault(key, rel) | |
| if existing != rel: | |
| sys.exit(f"Conflicting definitions for {key}:\n {existing}\n {rel}") | |
| def add_hierarchy(self, row: dict) -> str: | |
| """Add Subject -> Topic -> SubTopic -> Construct from one row; returns the Construct id.""" | |
| ids = {} # label -> node id for THIS row, so each level can find its parent | |
| for label, id_col, id_prop, name_col, parent in HIERARCHY: | |
| ids[label] = self.add_node(label, id_prop, row[id_col], row[name_col]) | |
| if parent: # everything except Subject hangs off the level above | |
| # Each child has exactly one parent - catch a source change that breaks the tree. | |
| # (add_rel alone wouldn't notice: a second parent is a *different* key, | |
| # so it would just quietly add a second CONTAINS edge.) | |
| known = self.parent.setdefault(ids[label], ids[parent]) | |
| if known != ids[parent]: | |
| sys.exit(f"{ids[label]} has several parents: {known}, {ids[parent]}") | |
| self.add_rel(CONTAINS[label], ids[parent], ids[label]) | |
| return ids["Construct"] | |
| def build(csv_dir: Path, out_dir: Path, tag: str = DEFAULT_TAG, fetch: bool = True) -> tuple[Path, Path]: | |
| """CSVs -> nodes.jsonl / relationships.jsonl. Returns the two output paths. | |
| This is also what load_eedi_graph.py calls for its --download option.""" | |
| if fetch: | |
| download(tag, csv_dir) | |
| for name in CSV_NAMES: | |
| if not (csv_dir / name).is_file(): | |
| sys.exit(f"{csv_dir / name} not found - drop --no-download, or pass --csv-dir") | |
| g = Graph() | |
| # 1) construct-map: one row per Construct -> builds the full curriculum tree. | |
| for row in read_csv(csv_dir / "construct-map.csv"): | |
| g.add_hierarchy(row) | |
| # 2) misconception-map: one row per (Misconception, Construct) pair. | |
| # It repeats the hierarchy columns too; re-adding them is a no-op, and it | |
| # doubles as a check that both files agree on the tree. | |
| for row in read_csv(csv_dir / "misconception-map.csv"): | |
| construct = g.add_hierarchy(row) | |
| misconception = g.add_node("Misconception", "misconceptionId", row["MisconceptionId"], row["MisconceptionName"]) | |
| # Share of this misconception's tags that fall in this construct (sums to ~100 | |
| # per misconception) - stored as a property on the relationship. | |
| pct = float(row["PercentageMisconceptionExistsInThisConstruct"]) | |
| g.add_rel("CONSTRUCT_HAS_MISCONCEPTION", construct, misconception, {"percentage": pct}) | |
| # 3) Write one JSON object per line. ensure_ascii=False keeps characters like | |
| # '÷' or '²' readable in the file instead of escaping them to \u00f7. | |
| out_dir.mkdir(parents=True, exist_ok=True) | |
| nodes_path, rels_path = out_dir / "nodes.jsonl", out_dir / "relationships.jsonl" | |
| with open(nodes_path, "w", encoding="utf-8") as f: | |
| for n in g.nodes.values(): | |
| f.write(json.dumps(n, ensure_ascii=False) + "\n") | |
| with open(rels_path, "w", encoding="utf-8") as f: | |
| for r in g.rels.values(): | |
| f.write(json.dumps(r, ensure_ascii=False) + "\n") | |
| # 4) Summary. `:28s` pads to 28 chars, `:>8,` right-aligns with thousands separators. | |
| for label, c in Counter(n["labels"][0] for n in g.nodes.values()).items(): | |
| print(f" nodes {label:28s} {c:>8,}") | |
| for rtype, c in Counter(r["type"] for r in g.rels.values()).items(): | |
| print(f" rels {rtype:32s} {c:>8,}") | |
| print(f"Wrote {len(g.nodes):,} nodes -> {nodes_path}") | |
| print(f"Wrote {len(g.rels):,} relationships -> {rels_path}") | |
| return nodes_path, rels_path | |
| def main(): | |
| # description=__doc__ reuses the module docstring at the top as the --help text. | |
| ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) | |
| ap.add_argument("--csv-dir", type=Path, | |
| help="where the CSVs live / are downloaded to " | |
| "(default: ../data if it has them, else this script's folder)") | |
| ap.add_argument("--out-dir", type=Path, default=SCRIPT_DIR, | |
| help="where to write the JSONL (default: this script's folder)") | |
| ap.add_argument("--tag", default=DEFAULT_TAG, help=f"Hugging Face revision (default {DEFAULT_TAG})") | |
| ap.add_argument("--no-download", action="store_true", help="never download; CSVs must already be in --csv-dir") | |
| args = ap.parse_args() | |
| build(args.csv_dir or default_csv_dir(), args.out_dir, args.tag, fetch=not args.no_download) | |
| # Only run main() when executed as a script - not when load_eedi_graph.py imports | |
| # this file to reuse build(). | |
| if __name__ == "__main__": | |
| main() | |