File size: 23,141 Bytes
fb9a4be
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
#!/usr/bin/env python3
"""
Load the Eedi Misconceptions Graph (nodes.jsonl / relationships.jsonl, built by
csv_to_jsonl.py from the Hugging Face release) into Neo4j (Aura or local).

Source: https://huggingface.co/datasets/Eedi/Eedi-Misconceptions-Graph (CC BY 4.0)

  (:Subject)-[:SUBJECT_CONTAINS_TOPIC]->(:Topic)-[:TOPIC_CONTAINS_SUBTOPIC]->(:SubTopic)
  (:SubTopic)-[:SUBTOPIC_CONTAINS_CONSTRUCT]->(:Construct)
  (:Construct)-[:CONSTRUCT_HAS_MISCONCEPTION {percentage}]->(:Misconception)

Every node also carries the label EediNode and a unique `uri` (e.g. eedi:construct:27).
A small derived layer adds count properties (skip with --no-derived).

Usage
-----
  pip install neo4j python-dotenv
  # Credentials come from the nearest .env above this script (or the current folder); either style works:
  #   NEO4J_URI=bolt://localhost:7687        or   NEO4J_URI_LOCAL=bolt://localhost:7687
  #   NEO4J_USERNAME=neo4j                        NEO4J_USERNAME_LOCAL=neo4j
  #   NEO4J_PASSWORD=...                          NEO4J_PASSWORD_LOCAL=...
  #   NEO4J_DATABASE=eedi-v1  (optional)          NEO4J_DATABASE_LOCAL=eedi-v1
  python load_eedi_graph.py --download                # build the JSONL from the CSVs, then load
  python load_eedi_graph.py --download --target LOCAL # use the *_LOCAL variables (required if others exist)

Safety: refuses to run against a database that already contains nodes unless
--allow-nonempty (merge into it) or --wipe (delete everything first) is given.
"""
# How this works, in order (see main() at the bottom)
# ---------------------------------------------------
#   1. Read credentials from .env and work out which Neo4j instance + database to use.
#   2. (--download) Build the JSONL from the Hugging Face CSVs via csv_to_jsonl.py.
#   3. Connect; create the database if needed; refuse to touch a non-empty one.
#   4. Create constraints/indexes BEFORE loading - they make the loading lookups fast.
#   5. Load nodes, then relationships (relationships need their end nodes to exist).
#   6. Add derived count properties, then re-count everything to verify the load.
#
# The core loading pattern (step 5) is "UNWIND + MERGE in batches":
#   - We send the database a *list* of rows as one query parameter ($rows), and
#     UNWIND turns that list back into one row per item inside Cypher. One round
#     trip per 5,000 rows is far faster than one query per node.
#   - MERGE = "find this, or create it if missing". Unlike CREATE it is idempotent,
#     so re-running the loader (with --allow-nonempty) updates rather than duplicates.

# Lets us write type hints like `str | None` on older Pythons (3.8/3.9).
from __future__ import annotations

import argparse
import json
import os
import re
import sys
import time
from collections import defaultdict
from pathlib import Path

DEFAULT_TAG = "v1.0"           # Hugging Face revision of the CSVs
DEFAULT_DATABASE = "eedi-v1"   # Neo4j database name, kept in step with the data version

# Labels and relationship types can't be passed as Cypher parameters, so we have to
# paste them into the query text. This pattern whitelists "plain identifier" names
# so nothing odd from a data file can ever end up injected into a query.
SAFE_NAME = re.compile(r"^[A-Za-z][A-Za-z0-9_]*$")


# --------------------------------------------------------------------------- helpers
def safe(name: str) -> str:
    """Return `name` unchanged if it's a safe label/type name, else raise."""
    if not SAFE_NAME.match(name):
        raise ValueError(f"Unsafe label/type name: {name!r}")
    return name


def batched(seq, n):
    """Yield successive slices of `seq` of length n (the last may be shorter)."""
    for i in range(0, len(seq), n):
        yield seq[i : i + n]


# Folder this script lives in - default location for the JSONL files and the
# starting point when searching for a .env.
SCRIPT_DIR = Path(__file__).resolve().parent


def read_env_file(env_file: Path | None) -> None:
    """Load NEO4J_* settings from a .env file into os.environ (via python-dotenv).

    With no --env-file, find the nearest .env walking upward - first from this
    script's folder, then from the directory you ran it in. e.g. from
    my-project/eedi/scripts/ it checks scripts/, then eedi/, then my-project/,
    so one .env at the top of a project covers everything below it."""
    # Imported here, not at the top, so --help works before anything is installed.
    from dotenv import find_dotenv, load_dotenv

    if env_file is None:
        # find_dotenv() starts from the folder of the file that calls it (this
        # script); usecwd=True starts from the current directory instead.
        # Both return "" when nothing is found.
        found = find_dotenv() or find_dotenv(usecwd=True)
        env_file = Path(found) if found else None
    if env_file is None or not env_file.is_file():
        print(f"No .env found ({env_file or 'searched upward from ' + str(SCRIPT_DIR) + ' and ' + os.getcwd()})"
              " - using environment variables only")
        return
    # override=False (the default): a variable already set in your shell wins
    # over the same name in the file.
    load_dotenv(env_file, override=False)
    print(f"Read settings from {env_file}")


def neo4j_settings(target: str | None) -> tuple[str, str, str, str, list[str]]:
    """Resolve URI/user/password/database and report which variables were used.

    Targets are the URI variables present: NEO4J_URI -> 'DEFAULT', NEO4J_URI_LOCAL -> 'LOCAL', ...
    With several present you must choose one with --target, so an Aura instance and a local
    one can never be mixed up silently. Credentials never fall back across targets."""
    # Build {target name: variable suffix}, e.g. {"DEFAULT": "", "LOCAL": "_LOCAL"}.
    targets = {}
    if "NEO4J_URI" in os.environ:
        targets["DEFAULT"] = ""
    for k in os.environ:
        m = re.fullmatch(r"NEO4J_URI_(\w+)", k)
        if m:
            targets[m.group(1).upper()] = f"_{m.group(1)}"
    if not targets:
        sys.exit("No NEO4J_URI / NEO4J_URI_<TARGET> variable found (checked the .env and environment).")

    # No --target given: fine if there's only one choice, otherwise list the
    # options and stop rather than guess.
    if target is None:
        if len(targets) > 1:
            opts = ", ".join(f"--target {t}  ({'NEO4J_URI' + sfx} = {os.environ['NEO4J_URI' + sfx]})"
                             for t, sfx in sorted(targets.items()))
            sys.exit(f"Several Neo4j targets are configured - choose one:\n  " + opts.replace(", --", "\n  --"))
        target = next(iter(targets))
    target = target.upper()
    if target not in targets:
        sys.exit(f"--target {target}: no NEO4J_URI{'_' + target if target != 'DEFAULT' else ''} set. "
                 f"Available: {', '.join(sorted(targets))}")
    sfx = targets[target]
    used = []  # which variable names we actually read - printed so you can see the source

    def get(*names, default=None):
        # Try each candidate variable name in order; first one *present* wins
        # (an empty value like PASSWORD='' counts as set).
        for n in names:
            if n in os.environ:
                used.append(n)
                return os.environ[n]
        if default is not None:
            return default
        sys.exit(f"Missing {names[0]} for target {target}.")

    uri = get(f"NEO4J_URI{sfx}")
    user = get(f"NEO4J_USERNAME{sfx}", f"NEO4J_USER{sfx}", default="neo4j")
    password = get(f"NEO4J_PASSWORD{sfx}")
    # Database lookup order:
    #   LOCAL target:   NEO4J_DATABASE_LOCAL, then NEO4J_DATABASE_EEDI
    #   DEFAULT target: NEO4J_DATABASE_EEDI, then NEO4J_DATABASE
    #   ...then DEFAULT_DATABASE. NEO4J_DATABASE_EEDI sits above the generic
    #   NEO4J_DATABASE so this graph doesn't land in a database meant for something else.
    db_vars = ([f"NEO4J_DATABASE{sfx}"] if sfx else []) + ["NEO4J_DATABASE_EEDI"] + ([] if sfx else ["NEO4J_DATABASE"])
    database = get(*db_vars, default=DEFAULT_DATABASE)
    return uri, user, password, database, used


def build_jsonl(tag: str, dest: Path) -> None:
    """Run csv_to_jsonl.py (shipped alongside this script): download CSVs, write JSONL."""
    try:
        import csv_to_jsonl
    except ImportError:
        sys.exit(f"csv_to_jsonl.py not found next to {Path(__file__).name} - it is needed for --download")
    csv_to_jsonl.build(csv_to_jsonl.default_csv_dir(), dest, tag)


def prepare_node(raw: dict) -> dict:
    """Turn a JSONL node into {labels, props}. Adds uri.

    The JSONL id ('eedi:construct:27') becomes the `uri` property - the single key
    we use to find any node, whatever its label."""
    props = dict(raw["properties"])  # copy, so we don't mutate the parsed JSON
    props["uri"] = raw["id"]
    return {"labels": [safe(l) for l in raw["labels"]], "props": props}


# --------------------------------------------------------------------------- loading
def check_empty(session, allow_nonempty: bool, wipe: bool, where: str = ""):
    """Guard against loading on top of existing data by accident."""
    count = session.run("MATCH (n) RETURN count(n) AS c").single()["c"]
    if count == 0:
        return
    if wipe:
        print(f"--wipe: deleting {count:,} existing nodes ...")
        # DETACH DELETE removes each node plus its relationships. Doing it
        # IN TRANSACTIONS OF 5000 ROWS commits in chunks, so deleting a large graph
        # doesn't need one enormous transaction held in memory.
        session.run(
            "MATCH (n) CALL { WITH n DETACH DELETE n } IN TRANSACTIONS OF 5000 ROWS"
        ).consume()
        return
    if not allow_nonempty:
        sys.exit(
            f"{where} already contains {count:,} nodes. Point at a fresh database, "
            "or pass --allow-nonempty (merge) / --wipe (delete everything first)."
        )


# Neo4j's rules for database names: start with a letter; letters, digits, '.', '-'; 3-63 chars.
DB_NAME = re.compile(r"^[A-Za-z][A-Za-z0-9.\-]{2,62}$")


def ensure_database(driver, db: str):
    """Create the target database if it doesn't exist (needs Enterprise, which Neo4j Desktop provides).

    Database admin commands (SHOW/CREATE DATABASE) must run against the special
    `system` database, hence database_="system" below."""
    if db in ("neo4j", "system"):
        return  # built-in databases always exist
    if not DB_NAME.match(db):
        sys.exit(f"Invalid database name {db!r} (letters, digits, '.', '-'; 3-63 chars)")
    names = {r["name"] for r in driver.execute_query("SHOW DATABASES YIELD name", database_="system").records}
    if db.lower() in names:  # Neo4j stores database names in lower case
        return
    print(f"Database '{db}' not found - creating it ...")
    try:
        # Backticks are needed because names like `eedi-v1` contain a hyphen.
        # WAIT blocks until the new database is online and ready for queries.
        driver.execute_query(f"CREATE DATABASE `{db}` IF NOT EXISTS WAIT", database_="system")
    except Exception as e:  # e.g. Community edition / Aura: single database only
        sys.exit(f"Could not create database '{db}': {e}\n"
                 "Create it yourself (CREATE DATABASE ...) or set the database to 'neo4j'.")


def create_schema(session):
    """Constraints and indexes. All IF NOT EXISTS, so safe to re-run.

    A uniqueness constraint does two jobs: it stops duplicates, and it creates an
    index behind the scenes. That index is what makes the MERGE / MATCH on `uri`
    during loading a fast lookup instead of a scan of every node."""
    stmts = [
        # The loading key: every node has the EediNode label and a unique uri.
        "CREATE CONSTRAINT eedi_uri IF NOT EXISTS FOR (n:EediNode) REQUIRE n.uri IS UNIQUE",
        # The human-facing keys: integer ids per label, for queries like
        # MATCH (c:Construct {constructId: 27}).
        "CREATE CONSTRAINT subject_id IF NOT EXISTS FOR (n:Subject) REQUIRE n.subjectSubjectId IS UNIQUE",
        "CREATE CONSTRAINT topic_id IF NOT EXISTS FOR (n:Topic) REQUIRE n.topicSubjectId IS UNIQUE",
        "CREATE CONSTRAINT subtopic_id IF NOT EXISTS FOR (n:SubTopic) REQUIRE n.subTopicSubjectId IS UNIQUE",
        "CREATE CONSTRAINT construct_id IF NOT EXISTS FOR (n:Construct) REQUIRE n.constructId IS UNIQUE",
        "CREATE CONSTRAINT misconception_id IF NOT EXISTS FOR (n:Misconception) REQUIRE n.misconceptionId IS UNIQUE",
        # Full-text (Lucene) index for word search across names, e.g.
        #   CALL db.index.fulltext.queryNodes('eedi_text', 'place value')
        "CREATE FULLTEXT INDEX eedi_text IF NOT EXISTS "
        "FOR (n:Subject|Topic|SubTopic|Construct|Misconception) ON EACH [n.name]",
    ]
    for s in stmts:
        # .consume() runs the query to completion and discards the (empty) result.
        session.run(s).consume()
    # Indexes build in the background; wait (up to 300s) until they're ready to use.
    session.run("CALL db.awaitIndexes(300)").consume()


def load_nodes(driver, db, path: Path, batch: int) -> dict[str, int]:
    """Load nodes.jsonl. Returns {label: count} for verify()."""
    # Group nodes by label set. A label can't be a query parameter, so we need
    # one query per label combination, with the label written into the query text.
    groups: dict[tuple, list] = defaultdict(list)
    with open(path, encoding="utf-8") as f:
        for line in f:  # JSONL: each line is one node
            n = prepare_node(json.loads(line))
            groups[tuple(sorted(n["labels"]))].append(n["props"])
    counts = {}
    for labels, rows in groups.items():
        label_str = "".join(f":{l}" for l in labels)  # ["Construct"] -> ":Construct"
        # For each row: find-or-create the node by uri (using the shared EediNode
        # label, so the eedi_uri constraint's index is used), then copy every
        # property onto it (`+=` merges the row map in) and add its real label.
        q = (
            "UNWIND $rows AS row "
            "MERGE (n:EediNode {uri: row.uri}) "
            f"SET n += row, n{label_str}"
        )
        for chunk in batched(rows, batch):
            # execute_query runs each call in its own transaction, retrying on
            # transient errors (e.g. a brief Aura connection blip).
            driver.execute_query(q, rows=chunk, database_=db)
        counts["|".join(labels)] = len(rows)
        print(f"  nodes  {'|'.join(labels):28s} {len(rows):>8,}")
    return counts


def load_rels(driver, db, path: Path, batch: int):
    """Load relationships.jsonl. Returns {type: count} for verify()."""
    # Same idea as load_nodes: a relationship type can't be a parameter, so group
    # by type and run one query per type. Each row is shrunk to just
    # s(tart uri), e(nd uri) and p(roperties) to keep the payload small.
    groups: dict[str, list] = defaultdict(list)
    with open(path, encoding="utf-8") as f:
        for line in f:
            r = json.loads(line)
            groups[r["type"]].append({"s": r["startNodeId"], "e": r["endNodeId"], "p": r.get("properties") or {}})
    counts = {}
    # Biggest groups first, so any problem shows up early (purely cosmetic ordering).
    for rtype, rows in sorted(groups.items(), key=lambda kv: -len(kv[1])):
        t = safe(rtype)
        # Look up both end nodes by uri (index lookups thanks to eedi_uri), then
        # find-or-create the relationship between them and copy its properties
        # on (e.g. `percentage` on CONSTRUCT_HAS_MISCONCEPTION).
        # Note: MATCH, not MERGE, for the end nodes - if a uri were missing the row
        # would silently produce no relationship, which verify() would then catch.
        q = (
            "UNWIND $rows AS row "
            "MATCH (s:EediNode {uri: row.s}) MATCH (e:EediNode {uri: row.e}) "
            f"MERGE (s)-[r:{t}]->(e) "
            "SET r += row.p"
        )
        for chunk in batched(rows, batch):
            driver.execute_query(q, rows=chunk, database_=db)
        counts[t] = len(rows)
        print(f"  rels   {t:32s} {len(rows):>8,}")
    return counts


# --------------------------------------------------------------------------- derived layer
# Extra properties computed from the loaded graph (not present in the source CSVs).
# Handy for filtering without writing the traversal every time, e.g.
#   MATCH (m:Misconception) WHERE m.subjectCount = 4 RETURN m.name
# Each entry is (description printed while running, Cypher query).
DERIVED = [
    (
        "Misconception.constructCount / subTopicCount / topicCount / subjectCount (how widely it spans)",
        # Walk from each misconception up the tree to its Subjects, then count the
        # DISTINCT nodes reached at each level. A misconception tagged in 5 constructs
        # that all sit in one subtopic gets constructCount=5, subTopicCount=1.
        """MATCH (m:Misconception)<-[:CONSTRUCT_HAS_MISCONCEPTION]-(c:Construct)
                 <-[:SUBTOPIC_CONTAINS_CONSTRUCT]-(st:SubTopic)
                 <-[:TOPIC_CONTAINS_SUBTOPIC]-(t:Topic)
                 <-[:SUBJECT_CONTAINS_TOPIC]-(s:Subject)
           WITH m, count(DISTINCT c) AS cc, count(DISTINCT st) AS stc, count(DISTINCT t) AS tc, count(DISTINCT s) AS sc
           SET m.constructCount = cc, m.subTopicCount = stc, m.topicCount = tc, m.subjectCount = sc""",
    ),
    (
        "Construct.misconceptionCount",
        # COUNT { pattern } is a Neo4j 5 "count subquery": the number of matches of
        # that pattern for this construct.
        """MATCH (c:Construct)
           SET c.misconceptionCount = COUNT { (c)-[:CONSTRUCT_HAS_MISCONCEPTION]->(:Misconception) }""",
    ),
]


def build_derived(session):
    for desc, q in DERIVED:
        t0 = time.time()
        # .counters reports what the query changed (nodes/relationships/properties).
        s = session.run(q).consume().counters
        print(f"  {desc}: {s.properties_set:,} props ({time.time()-t0:.1f}s)")


# --------------------------------------------------------------------------- verify
def verify(session, node_counts, rel_counts):
    """Re-count what's in the database and compare with what we sent.

    Nodes use >= (the database may legitimately hold more if --allow-nonempty
    merged into existing data); relationships must match exactly."""
    ok = True
    for k, expected in node_counts.items():
        label = k.split("|")[0]
        got = session.run(f"MATCH (n:{label}) RETURN count(n) AS c").single()["c"]
        if got < expected:
            ok = False
            print(f"  MISMATCH {label}: expected >= {expected}, got {got}")
    for t, expected in rel_counts.items():
        got = session.run(f"MATCH ()-[r:{t}]->() RETURN count(r) AS c").single()["c"]
        if got != expected:
            ok = False
            print(f"  MISMATCH {t}: expected {expected}, got {got}")
    print("  verification", "PASSED" if ok else "FAILED")
    return ok


def main():
    # ---- command-line options (description=__doc__ reuses the docstring as --help text)
    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("--data-dir", type=Path, default=SCRIPT_DIR,
                    help="where the JSONL files live / are built in (default: this script's folder)")
    ap.add_argument("--nodes", type=Path, help="override path to nodes.jsonl")
    ap.add_argument("--rels", type=Path, help="override path to relationships.jsonl")
    ap.add_argument("--env-file", type=Path,
                    help="dotenv file to read (default: nearest .env above this script's folder, "
                         "then above the current folder)")
    ap.add_argument("--database", help=f"database name (overrides the .env value; default '{DEFAULT_DATABASE}')")
    ap.add_argument("--target", help="which credentials: LOCAL -> NEO4J_*_LOCAL, DEFAULT -> plain NEO4J_*. "
                                     "Required when more than one is configured.")
    ap.add_argument("--download", action="store_true",
                    help="(re)build the JSONL from the CSVs first - using ../data if present, "
                         "else downloading them from Hugging Face")
    ap.add_argument("--tag", default=DEFAULT_TAG, help=f"Hugging Face revision (default {DEFAULT_TAG})")
    ap.add_argument("--no-derived", action="store_true", help="skip the derived count properties")
    ap.add_argument("--batch", type=int, default=5000)
    ap.add_argument("--allow-nonempty", action="store_true")
    ap.add_argument("--wipe", action="store_true", help="DELETE ALL existing data first")
    args = ap.parse_args()

    # ---- 1. credentials and target
    read_env_file(args.env_file)
    uri, user, password, db, used = neo4j_settings(args.target)
    db = args.database or db  # --database on the command line beats the .env
    print(f"Target: {uri}  database '{db}'   (from {', '.join(used)}{', --database' if args.database else ''})")

    # ---- 2. input files
    if args.download:
        build_jsonl(args.tag, args.data_dir)
    args.nodes = args.nodes or args.data_dir / "nodes.jsonl"
    args.rels = args.rels or args.data_dir / "relationships.jsonl"
    for p in (args.nodes, args.rels):
        if not p.is_file():
            sys.exit(f"{p} not found - run with --download (or csv_to_jsonl.py), or pass --data-dir / --nodes / --rels")

    from neo4j import GraphDatabase  # imported late so --help works without the driver

    if password == "":
        print("Password is empty - connecting without authentication (fine only if auth is disabled).")
        auth = None
    else:
        auth = (user, password)

    t0 = time.time()
    # The driver manages a pool of connections; `with` closes them all at the end.
    with GraphDatabase.driver(uri, auth=auth) as driver:
        # ---- 3. connect, create database, safety check
        driver.verify_connectivity()  # fail fast on a wrong URI/password
        print(f"Connected to {uri}")
        ensure_database(driver, db)
        print(f"Using database '{db}'")
        # A session is a short-lived "conversation" with one database; used here for
        # the one-off admin queries. Bulk loading uses driver.execute_query instead.
        with driver.session(database=db) as s:
            check_empty(s, args.allow_nonempty, args.wipe, f"Database '{db}' at {uri}")
            # ---- 4. schema first, so the loading lookups below are indexed
            print("Creating constraints & indexes ...")
            create_schema(s)
        # ---- 5. data: nodes before relationships
        print("Loading nodes ...")
        nc = load_nodes(driver, db, args.nodes, args.batch)
        print("Loading relationships ...")
        rc = load_rels(driver, db, args.rels, args.batch)
        # ---- 6. derived properties and verification
        with driver.session(database=db) as s:
            if not args.no_derived:
                print("Building derived properties ...")
                build_derived(s)
            print("Verifying ...")
            verify(s, nc, rc)
    print(f"Done in {time.time()-t0:.0f}s")


if __name__ == "__main__":
    main()