DigoryS's picture
Add graph JSONL converter and Neo4j loader (#2)
fb9a4be
Raw History Blame Contribute Delete
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()