Release 2.0.0 VBPL portal refresh

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.venv/
+.ruff_cache/
+.pytest_cache/
+
+# Local crawl and rollback artifacts; published Parquet files stay tracked.
+data/*_raw.jsonl
+data/refresh_*/
+data/archive_pre_refresh_*/
+data/_*/

CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+## 2.0.0 — 2026-07-23
+
+### Dataset
+
+- Refreshed the active dataset from the current VBPL Next.js catalog and JSON gateway.
+- Published 171,556 metadata rows, 170,824 unique HTML documents, and 1,033,255 unique relationship edges.
+- Added UUID and portal-prefixed document IDs; all active-config join keys are now strings.
+- Removed duplicate content rows while retaining historical records no longer listed by the portal.
+- Filled missing refresh metadata from the preceding published snapshot.
+- Split the incompatible `legacy` config into loadable `legacy_metadata` and `legacy_content` configs.
+- Re-encoded active Parquet files as bounded Arrow string row groups for Hugging Face `datasets` and Dataset Viewer compatibility.
+
+### Crawler and tooling
+
+- Replaced the retired VBPL crawl path with the current catalog server action and public document API.
+- Consolidated metadata, relationships, and full-text HTML into one resumable spider.
+- Added streaming JSONL-to-Parquet conversion, deterministic upsert, and comparison tools.
+- Removed the obsolete content spider, Pandas helper, and unused Scrapy item/pipeline boilerplate.
+- Added a reproducible `uv` project and lockfile.

README.md

@@ -28,49 +28,61 @@ configs:
   data_files:
   - split: data
     path: data/content.parquet
-- config_name: legacy
+- config_name: legacy_metadata
   data_files:
-  - split: content
-    path: legacy/content.parquet
   - split: metadata
     path: legacy/metadata.parquet
+- config_name: legacy_content
+  data_files:
+  - split: content
+    path: legacy/content.parquet
 dataset_info:
-- config_name: legacy
+- config_name: legacy_metadata
   features:
   - name: id
     dtype: int64
   - name: document_number
-    dtype: string
+    dtype: large_string
   - name: title
-    dtype: string
+    dtype: large_string
   - name: legal_type
-    dtype: string
+    dtype: large_string
   - name: legal_sectors
-    dtype: string
+    dtype: large_string
   - name: issuing_authority
-    dtype: string
+    dtype: large_string
   - name: issuance_date
-    dtype: string
+    dtype: large_string
   - name: effect_date
-    dtype: string
+    dtype: large_string
   - name: effectless_date
-    dtype: string
+    dtype: large_string
   - name: effect_status
-    dtype: string
+    dtype: large_string
   - name: signers
-    dtype: string
+    dtype: large_string
   splits:
   - name: metadata
-    num_bytes: 137000000
+    num_bytes: 217111959
     num_examples: 518601
+  download_size: 51272673
+  dataset_size: 217111959
+- config_name: legacy_content
+  features:
+  - name: id
+    dtype: int64
   - name: content
-    num_bytes: 3507657146
+    dtype: large_string
+  splits:
+  - name: content
+    num_bytes: 10683289665
     num_examples: 518235
-  download_size: 3644657146
+  download_size: 3507657146
+  dataset_size: 10683289665
 - config_name: metadata
   features:
   - name: id
-    dtype: int64
+    dtype: string
   - name: title
     dtype: string
   - name: so_ky_hieu
@@ -103,23 +115,38 @@ dataset_info:
     dtype: string
   - name: tinh_trang_hieu_luc
     dtype: string
-  num_rows: 153420
+  splits:
+  - name: data
+    num_bytes: 81375915
+    num_examples: 171556
+  download_size: 15335252
+  dataset_size: 81375915
 - config_name: relationships
   features:
   - name: doc_id
-    dtype: int64
+    dtype: string
   - name: other_doc_id
     dtype: string
   - name: relationship
     dtype: string
-  num_rows: 897890
+  splits:
+  - name: data
+    num_bytes: 39475717
+    num_examples: 1033255
+  download_size: 9436116
+  dataset_size: 39475717
 - config_name: content
   features:
   - name: id
     dtype: string
   - name: content_html
     dtype: string
-  num_rows: 178665
+  splits:
+  - name: data
+    num_bytes: 5646405351
+    num_examples: 170824
+  download_size: 787193691
+  dataset_size: 5646405351
 ---
 
 # Vietnamese Legal Documents
@@ -132,12 +159,27 @@ A comprehensive collection of Vietnamese legal documents — laws, decrees, circ
 - **Language:** Vietnamese
 - **License:** [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/)
 
+## 2026 Portal Refresh
+
+This release migrates the active configs to the current VBPL Next.js catalog
+and public JSON gateway. It adds UUID and portal-prefixed records, removes
+duplicate content rows, refreshes document text and relationships, and retains
+records that disappeared from the live catalog as historical rows.
+
+**Migration note:** `metadata.id`, `content.id`, `relationships.doc_id`, and
+`relationships.other_doc_id` are now strings. Consumers that previously joined
+on integer IDs must cast their keys to string before upgrading. The former
+mixed-schema `legacy` config is now exposed as the loadable `legacy_metadata`
+and `legacy_content` configs.
+
+See [CHANGELOG.md](CHANGELOG.md) for the complete release summary.
+
 ## Quick Start
 
 ```python
 from datasets import load_dataset
 
-# Metadata for all 153k documents
+# Metadata for 171k documents
 meta = load_dataset("th1nhng0/vietnamese-legal-documents", "metadata", split="data")
 print(meta.to_pandas().head())
 
@@ -145,7 +187,7 @@ print(meta.to_pandas().head())
 rels = load_dataset("th1nhng0/vietnamese-legal-documents", "relationships", split="data")
 print(rels.to_pandas().head())
 
-# Full-text HTML content for ~149k documents
+# Full-text HTML content for 170k documents
 content = load_dataset("th1nhng0/vietnamese-legal-documents", "content", split="data")
 print(content.to_pandas().head())
 ```
@@ -165,21 +207,21 @@ print(citing[["id", "title", "relationship"]])
 
 ## Dataset Structure
 
-The dataset has four configs:
+The dataset has five configs:
 
 | Config | Split | Rows | Description |
 |---|---|---|---|
-| `metadata` | `data` | 153,420 | One row per document — 16 metadata fields |
-| `content` | `data` | 178,665 | Raw HTML full-text content |
-| `relationships` | `data` | 897,890 | Directed edges between documents |
-| `legacy` | `metadata` | 518,601 | Older crawl — English field names, more docs |
-| `legacy` | `content` | 518,235 | Plain-text content for older crawl |
+| `metadata` | `data` | 171,556 | One row per document — 17 metadata fields |
+| `content` | `data` | 170,824 | One unique raw HTML body per document |
+| `relationships` | `data` | 1,033,255 | Unique directed edges between documents |
+| `legacy_metadata` | `metadata` | 518,601 | Older crawl — English field names, more docs |
+| `legacy_content` | `content` | 518,235 | Plain-text content for older crawl |
 
 ### `metadata`
 
 | Column | Description |
 |---|---|
-| `id` | Unique document ID (int) |
+| `id` | Unique document ID (string; numeric, UUID, or portal-prefixed) |
 | `title` | Full Vietnamese title |
 | `so_ky_hieu` | Official number, e.g. `115/NQ-HĐBCQG` |
 | `ngay_ban_hanh` | Issuance date (`DD/MM/YYYY`) |
@@ -204,7 +246,7 @@ The dataset has four configs:
 | `id` | Document ID (join key → `metadata.id`) |
 | `content_html` | Raw HTML body of the document |
 
-> **Note:** Some documents in `metadata` do not have a corresponding entry in `content` because the portal only provides PDF scans for those documents (no HTML version available).
+> **Note:** 732 metadata rows do not have a corresponding `content` row. The portal does not expose an HTML body for those records (some are PDF-only).
 
 ### `relationships`
 
@@ -212,9 +254,13 @@ The dataset has four configs:
 |---|---|
 | `doc_id` | Source document ID (join key → `metadata.id`) |
 | `other_doc_id` | Target document ID |
-| `relationship` | Edge label  |
+| `relationship` | Edge label from the current portal; archived old-only pairs retain their historical label |
 
-### `legacy`
+Every `doc_id` is present in `metadata`. Relationship targets may reference
+documents outside the live catalog; 17,706 distinct `other_doc_id` values do
+not have a metadata row in this snapshot.
+
+### Legacy configs
 
 An older, larger crawl snapshot with ~518 k documents. Field names and enumerated values are in English (unlike the current configs which use Vietnamese originals). Dates are `YYYY-MM-DD`. Use this config when you need broader coverage at the cost of reduced metadata richness.
 
@@ -246,35 +292,52 @@ An older, larger crawl snapshot with ~518 k documents. Field names and enumerate
 ```python
 from datasets import load_dataset
 
-legacy_meta = load_dataset("th1nhng0/vietnamese-legal-documents", "legacy", split="metadata")
-legacy_content = load_dataset("th1nhng0/vietnamese-legal-documents", "legacy", split="content")
+legacy_meta = load_dataset("th1nhng0/vietnamese-legal-documents", "legacy_metadata", split="metadata")
+legacy_content = load_dataset("th1nhng0/vietnamese-legal-documents", "legacy_content", split="content")
 ```
 
-## Statistics
-
-![Documents by year](charts/docs_by_year.png)
-
-![Document type distribution](charts/legal_type_distribution.png)
+## Data Collection
 
-![Top issuing authorities](charts/top_authorities.png)
+All data was scraped from [vbpl.vn](https://vbpl.vn) using the [Scrapy](https://scrapy.org/) crawler under [`crawler/`](crawler/). The single `vbpl` spider targets the current Next.js catalog and public JSON detail gateway, collecting metadata, HTML content, signers, fields, and relationships in one pass. IDs are strings because the migrated portal uses numeric IDs, UUIDs, and prefixed identifiers.
 
-## Data Collection
+The current files were refreshed on 2026-07-23. Refresh rows are authoritative for overlapping IDs; missing refresh fields are filled from the prior dataset, and records no longer exposed by the live catalog are retained as historical rows.
 
-All data was scraped from [vbpl.vn](https://vbpl.vn) using a [Scrapy](https://scrapy.org/) crawler (included under [`crawler/`](crawler/)). Metadata and cross-document relationships were extracted directly from the portal's structured pages.
+For local rollback, the immediately preceding files are preserved under the
+Git-ignored `data/archive_pre_refresh_2026-07-23/` directory.
 
 ```bash
 cd crawler
+uv sync --extra validation
+
+uv run scrapy crawl vbpl -a seed_file=data/ids.txt
+uv run scrapy crawl vbpl -a seed_file=data/ids.txt -a proxy_file=proxies.txt
+uv run scrapy crawl vbpl -a seed_file=data/ids.txt -a resume=1 -a resume_from=../data/metadata_raw.jsonl
+
+# Crawl the complete catalog. This one pass includes metadata, relationships,
+# and full-text HTML.
+uv run scrapy crawl vbpl -a full=1 -a output=../data/metadata_raw.jsonl
+
+# Safely continue an interrupted full crawl.
+uv run scrapy crawl vbpl -a full=1 -a resume=1 -a resume_from=../data/metadata_raw.jsonl -a output=../data/metadata_raw.jsonl
+
+# Stream the combined crawl into separate, versioned Parquet files.
+uv run python build_full_dataset.py ../data/metadata_raw.jsonl ../data/refresh_YYYY-MM-DD
+
+# Upsert a verified refresh into a staging directory. Refresh values win,
+# missing values are recovered from the current data, and old-only rows remain.
+uv run python upsert_dataset.py ../data/refresh_YYYY-MM-DD ../data/upsert_YYYY-MM-DD
 
-scrapy crawl vbpl -a seed_file=data/ids.txt                          # basic
-scrapy crawl vbpl -a seed_file=data/ids.txt -a proxy_file=proxies.txt  # with proxies
-scrapy crawl vbpl -a seed_file=data/ids.txt -a resume=1               # resume
+# Validate card metadata, Parquet schemas/counts, uniqueness, and join integrity.
+uv run --extra validation python validate_release.py ..
 ```
 
-Output: `data/raw.jsonl`
+Both processing commands refuse to overwrite their output directory. Validate
+the staged Parquet files before promoting them into `data/`.
 
 ## Limitations
 
 - Coverage depends on what [vbpl.vn](https://vbpl.vn) has indexed; older or undigitized documents may be missing.
+- The live catalog can change during a long crawl. Use `-a resume=1` for a final catalog-only verification pass; zero newly scraped items means every currently listed ID is already present.
 - Effect status reflects the portal at crawl time and may lag behind real-world changes.
 - This is a snapshot, not a live mirror. Always cross-check with the portal for authoritative status.
 
@@ -298,4 +361,4 @@ The dataset contains names of document signatories (public officials acting in t
 
 Vietnamese legal documents are **public domain** under the [Law on Access to Information (No. 104/2016/QH13)](https://chinhphu.vn/default.aspx?pageid=27160&docid=184568) and the [Law on Promulgation of Legal Documents (No. 64/2025/QH15)](https://chinhphu.vn/?pageid=27160&docid=213327&classid=1&typegroupid=3).
 
-The compiled dataset (schema, processing, curation) is released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Not a substitute for legal advice.
+The compiled dataset (schema, processing, curation) is released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). Not a substitute for legal advice.

crawler/build_full_dataset.py

@@ -0,0 +1,124 @@
+"""Stream a combined VBPL JSONL crawl into versioned Parquet datasets."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+
+METADATA_FIELDS = (
+    "id",
+    "title",
+    "so_ky_hieu",
+    "ngay_ban_hanh",
+    "loai_van_ban",
+    "ngay_co_hieu_luc",
+    "ngay_het_hieu_luc",
+    "nguon_thu_thap",
+    "ngay_dang_cong_bao",
+    "nganh",
+    "linh_vuc",
+    "co_quan_ban_hanh",
+    "chuc_danh",
+    "nguoi_ky",
+    "pham_vi",
+    "thong_tin_ap_dung",
+    "tinh_trang_hieu_luc",
+    "crawl_status",
+)
+METADATA_SCHEMA = pa.schema([(field, pa.string()) for field in METADATA_FIELDS])
+CONTENT_SCHEMA = pa.schema([("id", pa.string()), ("content_html", pa.string())])
+RELATIONSHIP_SCHEMA = pa.schema(
+    [
+        ("doc_id", pa.string()),
+        ("other_doc_id", pa.string()),
+        ("relationship", pa.string()),
+    ]
+)
+
+
+def flush(writer: pq.ParquetWriter, rows: list[dict], schema: pa.Schema) -> None:
+    if rows:
+        writer.write_table(pa.Table.from_pylist(rows, schema=schema))
+        rows.clear()
+
+
+def build(input_path: Path, output_dir: Path, batch_size: int) -> dict[str, int]:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    paths = {
+        "metadata": output_dir / "metadata.parquet",
+        "content": output_dir / "content.parquet",
+        "relationships": output_dir / "relationships.parquet",
+    }
+    for path in paths.values():
+        if path.exists():
+            raise FileExistsError(f"Refusing to overwrite {path}")
+
+    counts = {"metadata": 0, "content": 0, "relationships": 0}
+    metadata_rows: list[dict] = []
+    content_rows: list[dict] = []
+    relationship_rows: list[dict] = []
+
+    with (
+        pq.ParquetWriter(paths["metadata"], METADATA_SCHEMA, compression="zstd") as metadata_writer,
+        pq.ParquetWriter(paths["content"], CONTENT_SCHEMA, compression="zstd") as content_writer,
+        pq.ParquetWriter(
+            paths["relationships"], RELATIONSHIP_SCHEMA, compression="zstd"
+        ) as relationship_writer,
+        input_path.open("r", encoding="utf-8") as source,
+    ):
+        for line_number, line in enumerate(source, 1):
+            if not line.strip():
+                continue
+            try:
+                item = json.loads(line)
+            except json.JSONDecodeError as exc:
+                raise ValueError(f"Invalid JSON on line {line_number}") from exc
+
+            item["id"] = str(item["id"])
+            metadata_rows.append({field: item.get(field) for field in METADATA_FIELDS})
+            counts["metadata"] += 1
+
+            content = item.get("content")
+            if isinstance(content, str) and content.strip():
+                content_rows.append({"id": item["id"], "content_html": content})
+                counts["content"] += 1
+
+            for relationship, other_ids in (item.get("relationships") or {}).items():
+                for other_id in other_ids or ():
+                    relationship_rows.append(
+                        {
+                            "doc_id": item["id"],
+                            "other_doc_id": str(other_id),
+                            "relationship": relationship,
+                        }
+                    )
+                    counts["relationships"] += 1
+
+            if len(metadata_rows) >= batch_size:
+                flush(metadata_writer, metadata_rows, METADATA_SCHEMA)
+                flush(content_writer, content_rows, CONTENT_SCHEMA)
+                flush(relationship_writer, relationship_rows, RELATIONSHIP_SCHEMA)
+
+        flush(metadata_writer, metadata_rows, METADATA_SCHEMA)
+        flush(content_writer, content_rows, CONTENT_SCHEMA)
+        flush(relationship_writer, relationship_rows, RELATIONSHIP_SCHEMA)
+
+    return counts
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input", type=Path)
+    parser.add_argument("output_dir", type=Path)
+    parser.add_argument("--batch-size", type=int, default=5_000)
+    args = parser.parse_args()
+    print(json.dumps(build(args.input, args.output_dir, args.batch_size), indent=2))
+
+
+if __name__ == "__main__":
+    main()

crawler/compare_content_text.py

@@ -0,0 +1,74 @@
+"""Compare visible text while ignoring HTML markup differences."""
+
+from __future__ import annotations
+
+import argparse
+import html as html_module
+import json
+import re
+import unicodedata
+from pathlib import Path
+
+import polars as pl
+
+
+IGNORED_HTML = re.compile(
+    r"<(head|script|style|noscript)\b[^>]*>.*?</\1\s*>", re.IGNORECASE | re.DOTALL
+)
+COMMENTS = re.compile(r"<!--.*?-->", re.DOTALL)
+TAGS = re.compile(r"<[^>]*>", re.DOTALL)
+
+
+def normalized_text(value: str | None) -> str:
+    if not value:
+        return ""
+    text = IGNORED_HTML.sub(" ", value)
+    text = COMMENTS.sub(" ", text)
+    text = TAGS.sub(" ", text)
+    text = html_module.unescape(text).replace("\xa0", " ")
+    text = unicodedata.normalize("NFC", text)
+    return "".join(text.split()).casefold()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("new_content", type=Path)
+    parser.add_argument("current_content", type=Path)
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+
+    new = (
+        pl.read_parquet(args.new_content)
+        .with_columns(pl.col("id").cast(pl.String))
+        .unique("id", keep="last")
+    )
+    current = (
+        pl.read_parquet(args.current_content)
+        .with_columns(pl.col("id").cast(pl.String))
+        .unique("id", keep="last")
+    )
+    shared = new.join(current, on="id", how="inner", suffix="_current")
+
+    exact = 0
+    changed = 0
+    for new_html, current_html in shared.select(
+        "content_html", "content_html_current"
+    ).iter_rows():
+        if normalized_text(new_html) == normalized_text(current_html):
+            exact += 1
+        else:
+            changed += 1
+
+    result = {
+        "shared_ids": shared.height,
+        "same_canonical_visible_text": exact,
+        "changed_canonical_visible_text": changed,
+    }
+    rendered = json.dumps(result, indent=2)
+    if args.output:
+        args.output.write_text(rendered + "\n", encoding="utf-8")
+    print(rendered)
+
+
+if __name__ == "__main__":
+    main()

crawler/compare_datasets.py

@@ -0,0 +1,198 @@
+"""Compare a refreshed VBPL export with the repository's current datasets."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+from pathlib import Path
+
+import polars as pl
+
+
+SHARED_METADATA_FIELDS = (
+    "title",
+    "so_ky_hieu",
+    "ngay_ban_hanh",
+    "loai_van_ban",
+    "ngay_co_hieu_luc",
+    "ngay_het_hieu_luc",
+    "ngay_dang_cong_bao",
+    "nganh",
+    "linh_vuc",
+    "co_quan_ban_hanh",
+    "chuc_danh",
+    "nguoi_ky",
+    "pham_vi",
+    "tinh_trang_hieu_luc",
+)
+
+
+def load(path: Path) -> pl.DataFrame:
+    return pl.read_parquet(path).with_columns(pl.col("id").cast(pl.String))
+
+
+def unique_ids(frame: pl.DataFrame) -> pl.DataFrame:
+    return frame.unique("id", keep="last")
+
+
+def count_join(left: pl.DataFrame, right: pl.DataFrame, how: str) -> int:
+    return left.select("id").join(right.select("id"), on="id", how=how).height
+
+
+def id_shape(value: str) -> str:
+    if value.isdigit():
+        return "numeric"
+    if re.fullmatch(r"[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}", value, re.I):
+        return "uuid"
+    prefix = re.sub(r"\d+$", "", value)
+    return prefix or "other"
+
+
+def bridge_by_number_and_date(new: pl.DataFrame, old: pl.DataFrame) -> int:
+    def keyed(frame: pl.DataFrame) -> pl.DataFrame:
+        return (
+            frame.with_columns(
+                pl.concat_str(
+                    pl.col("so_ky_hieu").fill_null("").str.strip_chars().str.to_lowercase(),
+                    pl.lit("|"),
+                    pl.col("ngay_ban_hanh").fill_null("").str.strip_chars(),
+                ).alias("key")
+            )
+            .filter(pl.col("key") != "|")
+            .group_by("key")
+            .agg(pl.col("id"))
+            .filter(pl.col("id").list.len() == 1)
+            .with_columns(pl.col("id").list.first())
+        )
+
+    new_only = new.join(old.select("id"), on="id", how="anti")
+    old_only = old.join(new.select("id"), on="id", how="anti")
+    return keyed(new_only).join(keyed(old_only), on="key", how="inner").height
+
+
+def compare(args: argparse.Namespace) -> dict:
+    new_meta_raw = load(args.new_dir / "metadata.parquet")
+    old_meta_raw = load(args.current_dir / "metadata.parquet")
+    new_meta = unique_ids(new_meta_raw)
+    old_meta = unique_ids(old_meta_raw)
+
+    shared = new_meta.join(old_meta, on="id", how="inner", suffix="_old")
+    field_changes = {}
+    changed_expressions = []
+    for field in SHARED_METADATA_FIELDS:
+        changed = (
+            pl.col(field).fill_null("").str.strip_chars()
+            != pl.col(f"{field}_old").fill_null("").str.strip_chars()
+        )
+        field_changes[field] = shared.select(changed.sum()).item()
+        changed_expressions.append(changed)
+
+    changed_shared_rows = shared.select(pl.any_horizontal(changed_expressions).sum()).item()
+    null_coverage = {}
+    for field in SHARED_METADATA_FIELDS:
+        missing = pl.col(field).is_null() | (pl.col(field).str.strip_chars() == "")
+        old_missing = pl.col(f"{field}_old").is_null() | (
+            pl.col(f"{field}_old").str.strip_chars() == ""
+        )
+        null_coverage[field] = {
+            "new_missing_on_shared_ids": shared.select(missing.sum()).item(),
+            "current_missing_on_shared_ids": shared.select(old_missing.sum()).item(),
+        }
+    shapes = {}
+    for value in new_meta["id"]:
+        shape = id_shape(value)
+        shapes[shape] = shapes.get(shape, 0) + 1
+
+    new_content_raw = load(args.new_dir / "content.parquet")
+    old_content_raw = load(args.current_dir / "content.parquet")
+    new_content = unique_ids(new_content_raw)
+    old_content = unique_ids(old_content_raw)
+    content_shared = new_content.join(old_content, on="id", how="inner", suffix="_old")
+    content_equal = content_shared.select(
+        (pl.col("content_html") == pl.col("content_html_old")).sum()
+    ).item()
+
+    new_rel = pl.read_parquet(args.new_dir / "relationships.parquet").with_columns(
+        pl.col("doc_id").cast(pl.String), pl.col("other_doc_id").cast(pl.String)
+    )
+    old_rel = pl.read_parquet(args.current_dir / "relationships.parquet").with_columns(
+        pl.col("doc_id").cast(pl.String), pl.col("other_doc_id").cast(pl.String)
+    )
+    rel_keys = ["doc_id", "other_doc_id", "relationship"]
+    new_rel_unique = new_rel.unique(rel_keys)
+    old_rel_unique = old_rel.unique(rel_keys)
+    shared_edges = new_rel_unique.join(old_rel_unique, on=rel_keys, how="inner").height
+    pair_keys = ["doc_id", "other_doc_id"]
+    new_pairs = new_rel_unique.unique(pair_keys)
+    old_pairs = old_rel_unique.unique(pair_keys)
+    shared_pairs = new_pairs.join(old_pairs, on=pair_keys, how="inner").height
+
+    legacy_meta = load(args.legacy_dir / "metadata.parquet")
+    legacy_content = load(args.legacy_dir / "content.parquet")
+    return {
+        "metadata": {
+            "new_rows": new_meta_raw.height,
+            "new_unique_ids": new_meta.height,
+            "new_duplicate_rows": new_meta_raw.height - new_meta.height,
+            "current_rows": old_meta_raw.height,
+            "current_unique_ids": old_meta.height,
+            "exact_id_overlap": count_join(new_meta, old_meta, "inner"),
+            "new_only_ids": count_join(new_meta, old_meta, "anti"),
+            "current_only_ids": count_join(old_meta, new_meta, "anti"),
+            "unique_number_date_matches_with_changed_id": bridge_by_number_and_date(
+                new_meta, old_meta
+            ),
+            "shared_rows_with_any_field_change": changed_shared_rows,
+            "field_change_counts": field_changes,
+            "missing_value_counts_on_shared_ids": null_coverage,
+            "new_id_shapes": dict(sorted(shapes.items())),
+        },
+        "content": {
+            "new_rows": new_content_raw.height,
+            "new_unique_ids": new_content.height,
+            "current_rows": old_content_raw.height,
+            "current_unique_ids": old_content.height,
+            "exact_id_overlap": content_shared.height,
+            "exact_html_matches": content_equal,
+            "changed_html": content_shared.height - content_equal,
+            "new_only_ids": count_join(new_content, old_content, "anti"),
+            "current_only_ids": count_join(old_content, new_content, "anti"),
+        },
+        "relationships": {
+            "new_rows": new_rel.height,
+            "new_unique_edges": new_rel_unique.height,
+            "current_rows": old_rel.height,
+            "current_unique_edges": old_rel_unique.height,
+            "exact_edge_overlap": shared_edges,
+            "document_pair_overlap_ignoring_label": shared_pairs,
+            "new_only_edges": new_rel_unique.height - shared_edges,
+            "current_only_edges": old_rel_unique.height - shared_edges,
+        },
+        "legacy": {
+            "metadata_rows": legacy_meta.height,
+            "metadata_exact_id_overlap_with_new": count_join(new_meta, unique_ids(legacy_meta), "inner"),
+            "content_rows": legacy_content.height,
+            "content_exact_id_overlap_with_new": count_join(
+                new_content, unique_ids(legacy_content), "inner"
+            ),
+        },
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("new_dir", type=Path)
+    parser.add_argument("--current-dir", type=Path, default=Path("../data"))
+    parser.add_argument("--legacy-dir", type=Path, default=Path("../legacy"))
+    parser.add_argument("--output", type=Path)
+    args = parser.parse_args()
+    result = compare(args)
+    rendered = json.dumps(result, ensure_ascii=False, indent=2)
+    if args.output:
+        args.output.write_text(rendered + "\n", encoding="utf-8")
+    print(rendered)
+
+
+if __name__ == "__main__":
+    main()

crawler/helper.py

@@ -1,58 +0,0 @@
-import pandas as pd
-import json
-import re
-import polars as pl
-
-
-def metadata_process():
-    df = pd.read_json("raw.jsonl", lines=True)
-    df = df.drop(columns=["content"])
-
-    # Export metadata parquet (without relationships)
-    metadata_df = df.drop(columns=["relationships"])
-    metadata_df.to_parquet("metadata.parquet", index=False)
-    print(f"✓ Exported metadata.parquet with shape {metadata_df.shape}")
-
-    # Build relationships dataframe
-    relationships_records = []
-
-    for doc_id, relationships_json in zip(df["id"], df["relationships"]):
-        rel_obj = (
-            json.loads(relationships_json)
-            if isinstance(relationships_json, str)
-            else relationships_json
-        )
-
-        for rel_type, other_ids in rel_obj.items():
-            # Remove count from relationship type: "Văn bản căn cứ (1)" -> "Văn bản căn cứ"
-            cleaned_rel_type = re.sub(r"\s*\(\d+\)\s*$", "", rel_type)
-
-            # other_ids is a list
-            for other_id in other_ids:
-                relationships_records.append(
-                    {
-                        "doc_id": doc_id,
-                        "other_doc_id": other_id,
-                        "relationship": cleaned_rel_type,
-                    }
-                )
-
-    relationships_df = pd.DataFrame(relationships_records)
-    # other_doc_id should be int too
-    relationships_df["other_doc_id"] = relationships_df["other_doc_id"].astype(int)
-    relationships_df.to_parquet("relationships.parquet", index=False)
-    print(f"✓ Exported relationships.parquet with shape {relationships_df.shape}")
-
-    print(f"\nRelationship types found:")
-    print(relationships_df["relationship"].value_counts())
-
-
-def content_process():
-    # scan_ndjson is lazy; sink_parquet streams the result directly to disk
-    pl.scan_ndjson("../data/raw.jsonl").sink_parquet("../data/content.parquet")
-    print("✓ Exported content.parquet via streaming")
-
-
-if __name__ == "__main__":
-    # metadata_process()
-    content_process()

crawler/pyproject.toml

@@ -0,0 +1,25 @@
+[project]
+name = "vbpl-crawler"
+version = "2.0.0"
+description = "Crawler and release tooling for the Vietnamese Legal Documents dataset"
+requires-python = ">=3.11"
+dependencies = [
+    "polars>=1.20",
+    "pyarrow>=18",
+    "scrapy>=2.13",
+]
+
+[project.optional-dependencies]
+validation = [
+    "datasets>=4",
+    "huggingface-hub>=0.30",
+]
+
+[dependency-groups]
+dev = ["ruff>=0.12"]
+
+[tool.uv]
+package = false
+
+[tool.ruff]
+target-version = "py311"

crawler/upsert_dataset.py

@@ -0,0 +1,176 @@
+"""Merge a verified VBPL refresh into the published Parquet datasets."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import polars as pl
+import pyarrow as pa
+import pyarrow.compute as pc
+import pyarrow.parquet as pq
+
+
+METADATA_FIELDS = (
+    "id",
+    "title",
+    "so_ky_hieu",
+    "ngay_ban_hanh",
+    "loai_van_ban",
+    "ngay_co_hieu_luc",
+    "ngay_het_hieu_luc",
+    "nguon_thu_thap",
+    "ngay_dang_cong_bao",
+    "nganh",
+    "linh_vuc",
+    "co_quan_ban_hanh",
+    "chuc_danh",
+    "nguoi_ky",
+    "pham_vi",
+    "thong_tin_ap_dung",
+    "tinh_trang_hieu_luc",
+)
+RELATIONSHIP_PAIR = ("doc_id", "other_doc_id")
+
+
+def string_columns(fields: tuple[str, ...]) -> list[pl.Expr]:
+    return [pl.col(field).cast(pl.String, strict=False) for field in fields]
+
+
+def write_huggingface_parquet(
+    frame: pl.LazyFrame,
+    output_path: Path,
+    fields: tuple[str, ...],
+    batch_size: int = 5_000,
+) -> None:
+    """Write bounded Arrow string row groups that ``datasets`` can load."""
+    intermediate = output_path.with_name(f".{output_path.name}.polars")
+    frame.sink_parquet(intermediate, compression="zstd")
+
+    schema = pa.schema([(field, pa.string()) for field in fields])
+    with pq.ParquetWriter(output_path, schema, compression="zstd") as writer:
+        parquet = pq.ParquetFile(intermediate)
+        for batch in parquet.iter_batches(batch_size=batch_size, columns=list(fields)):
+            table = pa.Table.from_arrays(
+                [pc.cast(batch.column(field), pa.string()) for field in fields],
+                schema=schema,
+            )
+            writer.write_table(table, row_group_size=batch_size)
+        parquet.close()
+
+    intermediate.unlink()
+
+
+def upsert_metadata(current_dir: Path, refresh_dir: Path, output_dir: Path) -> None:
+    current = (
+        pl.scan_parquet(current_dir / "metadata.parquet")
+        .select(string_columns(METADATA_FIELDS))
+        .unique("id", keep="last")
+    )
+    refresh = (
+        pl.scan_parquet(refresh_dir / "metadata.parquet")
+        .select(string_columns(METADATA_FIELDS))
+        .unique("id", keep="last")
+    )
+
+    current_values = current.rename(
+        {field: f"{field}_current" for field in METADATA_FIELDS if field != "id"}
+    )
+    joined = refresh.join(current_values, on="id", how="left")
+    merged_refresh = joined.select(
+        pl.col("id"),
+        *[
+            pl.when(pl.col(field).is_null() | (pl.col(field).str.strip_chars() == ""))
+            .then(pl.col(f"{field}_current"))
+            .otherwise(pl.col(field))
+            .alias(field)
+            for field in METADATA_FIELDS
+            if field != "id"
+        ],
+    )
+    current_only = current.join(refresh.select("id"), on="id", how="anti")
+    write_huggingface_parquet(
+        pl.concat([merged_refresh, current_only], how="vertical"),
+        output_dir / "metadata.parquet",
+        METADATA_FIELDS,
+    )
+
+
+def upsert_content(current_dir: Path, refresh_dir: Path, output_dir: Path) -> None:
+    current = (
+        pl.scan_parquet(current_dir / "content.parquet")
+        .select(pl.col("id").cast(pl.String), pl.col("content_html"))
+        .unique("id", keep="last")
+    )
+    refresh = (
+        pl.scan_parquet(refresh_dir / "content.parquet")
+        .select(pl.col("id").cast(pl.String), pl.col("content_html"))
+        .unique("id", keep="last")
+    )
+    current_only = current.join(refresh.select("id"), on="id", how="anti")
+    write_huggingface_parquet(
+        pl.concat([refresh, current_only], how="vertical"),
+        output_dir / "content.parquet",
+        ("id", "content_html"),
+    )
+
+
+def upsert_relationships(
+    current_dir: Path, refresh_dir: Path, output_dir: Path
+) -> None:
+    columns = ("doc_id", "other_doc_id", "relationship")
+    current = (
+        pl.scan_parquet(current_dir / "relationships.parquet")
+        .select(string_columns(columns))
+        .unique(columns)
+    )
+    refresh = (
+        pl.scan_parquet(refresh_dir / "relationships.parquet")
+        .select(string_columns(columns))
+        .unique(columns)
+    )
+
+    # The new portal renamed relationship labels. New edges therefore replace
+    # every old label for the same directed document pair. Only pairs absent
+    # from the current portal are retained with their historical labels.
+    refresh_pairs = refresh.select(RELATIONSHIP_PAIR).unique()
+    current_only_pairs = current.join(
+        refresh_pairs, on=RELATIONSHIP_PAIR, how="anti"
+    )
+    write_huggingface_parquet(
+        pl.concat([refresh, current_only_pairs], how="vertical").unique(columns),
+        output_dir / "relationships.parquet",
+        columns,
+    )
+
+
+def row_counts(output_dir: Path) -> dict[str, int]:
+    return {
+        name: pl.scan_parquet(output_dir / f"{name}.parquet")
+        .select(pl.len())
+        .collect()
+        .item()
+        for name in ("metadata", "content", "relationships")
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("refresh_dir", type=Path)
+    parser.add_argument("output_dir", type=Path)
+    parser.add_argument("--current-dir", type=Path, default=Path("../data"))
+    args = parser.parse_args()
+
+    if args.output_dir.exists():
+        raise FileExistsError(f"Refusing to overwrite {args.output_dir}")
+    args.output_dir.mkdir(parents=True)
+
+    upsert_metadata(args.current_dir, args.refresh_dir, args.output_dir)
+    upsert_content(args.current_dir, args.refresh_dir, args.output_dir)
+    upsert_relationships(args.current_dir, args.refresh_dir, args.output_dir)
+    print(json.dumps(row_counts(args.output_dir), indent=2))
+
+
+if __name__ == "__main__":
+    main()

crawler/validate_release.py

@@ -0,0 +1,89 @@
+"""Validate the local Hugging Face dataset release before publishing."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+import polars as pl
+import pyarrow.parquet as pq
+from huggingface_hub import DatasetCard
+
+
+CONFIG_PATHS = {
+    "metadata": ("data/metadata.parquet", "data"),
+    "relationships": ("data/relationships.parquet", "data"),
+    "content": ("data/content.parquet", "data"),
+    "legacy_metadata": ("legacy/metadata.parquet", "metadata"),
+    "legacy_content": ("legacy/content.parquet", "content"),
+}
+
+
+def validate(root: Path) -> dict[str, dict[str, int]]:
+    card = DatasetCard.load(root / "README.md")
+    card.validate()
+    metadata = card.data.to_dict()
+    infos = {item["config_name"]: item for item in metadata["dataset_info"]}
+    configs = {item["config_name"]: item for item in metadata["configs"]}
+    assert set(infos) == set(CONFIG_PATHS)
+    assert set(configs) == set(CONFIG_PATHS)
+
+    result = {}
+    for name, (relative_path, split_name) in CONFIG_PATHS.items():
+        path = root / relative_path
+        parquet = pq.ParquetFile(path)
+        info = infos[name]
+        split = next(item for item in info["splits"] if item["name"] == split_name)
+        card_path = configs[name]["data_files"][0]["path"]
+        feature_types = {
+            feature["name"]: feature["dtype"] for feature in info["features"]
+        }
+        parquet_types = {
+            field.name: str(field.type) for field in parquet.schema_arrow
+        }
+        assert card_path == relative_path
+        assert split["num_examples"] == parquet.metadata.num_rows
+        assert info["download_size"] == path.stat().st_size
+        assert feature_types == parquet_types
+        result[name] = {
+            "rows": parquet.metadata.num_rows,
+            "download_size": path.stat().st_size,
+        }
+        parquet.close()
+
+    frames = {
+        name: pl.scan_parquet(root / relative_path)
+        for name, (relative_path, _) in CONFIG_PATHS.items()
+        if name in {"metadata", "content", "relationships"}
+    }
+    metadata_ids = frames["metadata"].select("id")
+    content_ids = frames["content"].select("id")
+    relationship_sources = frames["relationships"].select(
+        pl.col("doc_id").alias("id")
+    )
+    assert metadata_ids.select(pl.len()).collect().item() == metadata_ids.unique().select(
+        pl.len()
+    ).collect().item()
+    assert content_ids.select(pl.len()).collect().item() == content_ids.unique().select(
+        pl.len()
+    ).collect().item()
+    assert frames["relationships"].select(pl.len()).collect().item() == frames[
+        "relationships"
+    ].unique().select(pl.len()).collect().item()
+    assert content_ids.join(metadata_ids, on="id", how="anti").collect().is_empty()
+    assert relationship_sources.join(
+        metadata_ids, on="id", how="anti"
+    ).collect().is_empty()
+    return result
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("root", type=Path, nargs="?", default=Path(".."))
+    args = parser.parse_args()
+    print(json.dumps(validate(args.root.resolve()), indent=2))
+
+
+if __name__ == "__main__":
+    main()

crawler/vbpl/api.py

@@ -0,0 +1,95 @@
+"""Helpers for the public VBPL JSON API and catalog action."""
+
+import json
+import re
+from datetime import datetime
+
+
+BASE_URL = "https://vbpl-bientap-gateway.moj.gov.vn/api"
+DOCUMENT_URL_TEMPLATE = f"{BASE_URL}/qtdc/public/doc/{{}}"
+CATALOG_URL = "https://vbpl.vn/van-ban/trung-uong"
+
+# The portal keeps catalog search behind a Next.js server action. This value can
+# be overridden with ``-a catalog_action_id=...`` after a future deployment.
+CATALOG_ACTION_ID = "c529d164f28418e5898a834422629e64c6816af1"
+
+
+def feed_settings(output_path):
+    """Build an explicit single-file Scrapy feed configuration."""
+    return {
+        output_path: {
+            "format": "jsonlines",
+            "encoding": "utf-8",
+            "overwrite": False,
+        }
+    }
+
+# Official relationship labels used by the current VBPL frontend.
+REFERENCE_TYPES = {
+    1: "Bãi bỏ",
+    2: "Bản dịch",
+    3: "Căn cứ",
+    4: "Dẫn chiếu",
+    5: "Đình chỉ thi hành",
+    6: "Đính chính",
+    7: "Hợp nhất",
+    8: "Hướng dẫn áp dụng",
+    9: "Quy định chi tiết, hướng dẫn thi hành",
+    10: "Sửa đổi, bổ sung",
+    11: "Tạm ngưng hiệu lực",
+    12: "Thay thế",
+    13: "Bổ sung",
+    14: "Giải thích",
+    15: "Công bố",
+}
+
+
+def unwrap_document(payload):
+    """Return document data from a successful gateway response."""
+    if not isinstance(payload, dict) or payload.get("success") is not True:
+        return None
+    data = payload.get("data")
+    return data if isinstance(data, dict) else None
+
+
+def format_date(value):
+    """Convert an API ISO datetime to the dataset's DD/MM/YYYY format."""
+    if not value:
+        return None
+    try:
+        return datetime.fromisoformat(value.replace("Z", "+00:00")).strftime("%d/%m/%Y")
+    except (TypeError, ValueError):
+        return value
+
+
+def join_unique(values):
+    """Join non-empty values while preserving their original order."""
+    unique = []
+    for value in values:
+        if value and value not in unique:
+            unique.append(value)
+    return ", ".join(unique) if unique else None
+
+
+def catalog_body(page_number, page_size):
+    """Build the argument array expected by the portal's catalog action."""
+    return json.dumps(
+        [{"pageNumber": page_number, "pageSize": page_size}],
+        ensure_ascii=False,
+        separators=(",", ":"),
+    )
+
+
+def unwrap_catalog(response_text):
+    """Extract catalog JSON from a Next.js React Server Components response."""
+    decoder = json.JSONDecoder()
+    # Large RSC strings use length-prefixed chunks, so the following JSON chunk
+    # is not necessarily line-aligned (for example ``...title1:{...}``).
+    for marker in re.finditer(r"[0-9a-f]+:(?=\{)", response_text):
+        try:
+            payload, _ = decoder.raw_decode(response_text, marker.end())
+        except json.JSONDecodeError:
+            continue
+        if isinstance(payload, dict) and isinstance(payload.get("items"), list):
+            return payload
+    return None

crawler/vbpl/items.py

@@ -1,11 +0,0 @@
-"""Item definitions for the VBPL crawler."""
-
-import scrapy
-
-
-class VbplItem(scrapy.Item):
-    """Optional structured item model.
-
-    The current spider yields plain dictionaries for flexibility.
-    Keep this class for teams that prefer explicit Scrapy item schemas.
-    """

crawler/vbpl/pipelines.py

@@ -1,11 +0,0 @@
-"""Pipelines for post-processing scraped items."""
-
-
-class VbplPipeline:
-    """Pass-through pipeline.
-
-    Enable in settings when you need centralized item validation or cleanup.
-    """
-
-    def process_item(self, item, spider):
-        return item

crawler/vbpl/settings.py

@@ -16,9 +16,10 @@ RANDOMIZE_DOWNLOAD_DELAY = False
 
 COOKIES_ENABLED = False
 
-# Proxy middleware is disabled by default.
-# Pass -a proxy_file=<path> to the spider to enable it.
-DOWNLOADER_MIDDLEWARES = {}
+# The spider removes this middleware unless ``-a proxy_file=<path>`` is passed.
+DOWNLOADER_MIDDLEWARES = {
+    "vbpl.middlewares.RotatingProxyMiddleware": 610,
+}
 
 USER_AGENT = (
     "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko)"
@@ -32,7 +33,7 @@ FEED_EXPORT_ENCODING = "utf-8"
 
 # Output goes to the dataset data/ folder (one level up from crawler/).
 FEEDS = {
-    "../data/raw.jsonl": {
+    "../data/metadata_raw.jsonl": {
         "format": "jsonlines",
         "encoding": "utf-8",
         "overwrite": False,

crawler/vbpl/spiders/vbpl.py

@@ -1,30 +1,43 @@
 import json
-import re
+import math
+from collections import defaultdict
 from pathlib import Path
-from urllib.parse import parse_qs, urlparse
 
 import scrapy
 
-# Base URLs for dynamic construction
-BASE_URL = "https://vbpl.vn"
-METADATA_URL_TEMPLATE = f"{BASE_URL}/TW/Pages/vbpq-thuoctinh.aspx?ItemID={{}}"
-LUOCDO_URL_TEMPLATE = f"{BASE_URL}/ninhbinh/Pages/vbpq-luocdo.aspx?ItemID={{}}"
+from vbpl.api import (
+    CATALOG_ACTION_ID,
+    CATALOG_URL,
+    DOCUMENT_URL_TEMPLATE,
+    REFERENCE_TYPES,
+    catalog_body,
+    feed_settings,
+    format_date,
+    join_unique,
+    unwrap_catalog,
+    unwrap_document,
+)
 
 
 class VbplSpider(scrapy.Spider):
-    """Crawl VBPL metadata pages and relationship graph from seed ItemIDs."""
+    """Crawl VBPL metadata and relationships from seed document IDs."""
 
     name = "vbpl"
 
     @classmethod
     def from_crawler(cls, crawler, *args, **kwargs):
         proxy_file = kwargs.get("proxy_file")
+        output = kwargs.get("output")
+        if output:
+            crawler.settings.set("FEEDS", feed_settings(output), priority="spider")
         if proxy_file:
             crawler.settings.set("PROXY_LIST_FILE", proxy_file, priority="spider")
         else:
-            mw = dict(crawler.settings.getwithbase("DOWNLOADER_MIDDLEWARES"))
-            mw.pop("vbpl.middlewares.RotatingProxyMiddleware", None)
-            crawler.settings.set("DOWNLOADER_MIDDLEWARES", mw, priority="spider")
+            middlewares = dict(crawler.settings.getwithbase("DOWNLOADER_MIDDLEWARES"))
+            middlewares.pop("vbpl.middlewares.RotatingProxyMiddleware", None)
+            crawler.settings.set(
+                "DOWNLOADER_MIDDLEWARES", middlewares, priority="spider"
+            )
         return super().from_crawler(crawler, *args, **kwargs)
 
     def __init__(
@@ -34,11 +47,21 @@ class VbplSpider(scrapy.Spider):
         proxy_file=None,
         resume=0,
         resume_from="data.jsonl",
+        full=0,
+        page_size=100,
+        max_pages=0,
+        catalog_action_id=CATALOG_ACTION_ID,
+        output=None,
         *args,
         **kwargs,
     ):
         super().__init__(*args, **kwargs)
         self.proxy_file = proxy_file
+        self.full = bool(int(full))
+        self.page_size = int(page_size)
+        self.max_pages = int(max_pages)
+        self.catalog_action_id = catalog_action_id
+        self.output = output
         if seed_file:
             self.seed_ids = [
                 line.strip()
@@ -47,19 +70,19 @@ class VbplSpider(scrapy.Spider):
             ]
         else:
             self.seed_ids = [item_id.strip() for item_id in str(seed_ids).split(",")]
+
         self.seen_ids = set()
         if int(resume):
             resume_path = Path(resume_from)
             if resume_path.exists():
-                for line in resume_path.read_text(encoding="utf-8").splitlines():
-                    line = line.strip()
-                    if line:
+                with resume_path.open(encoding="utf-8") as source:
+                    for line in source:
                         try:
                             item = json.loads(line)
-                            if "id" in item:
-                                self.seen_ids.add(str(item["id"]))
                         except json.JSONDecodeError:
-                            pass
+                            continue
+                        if "id" in item:
+                            self.seen_ids.add(str(item["id"]))
                 self.logger.info(
                     "Resume mode: loaded %d already-scraped IDs from %s",
                     len(self.seen_ids),
@@ -67,147 +90,208 @@ class VbplSpider(scrapy.Spider):
                 )
 
     async def start(self):
-        """Scrapy 2.13+ entry point when custom start_requests() is used."""
         for request in self.start_requests():
             yield request
 
     def start_requests(self):
-        """Start crawling from seed IDs."""
+        if self.full:
+            yield self._catalog_request(1)
+            return
         for item_id in self.seed_ids:
-            self.seen_ids.add(item_id)
-            yield scrapy.Request(
-                METADATA_URL_TEMPLATE.format(item_id),
-                callback=self.parse_metadata,
-                cb_kwargs={"doc_id": item_id, "content_html": None},
+            request = self._request_if_new(item_id)
+            if request:
+                yield request
+
+    def _catalog_request(self, page_number):
+        return scrapy.Request(
+            CATALOG_URL,
+            method="POST",
+            body=catalog_body(page_number, self.page_size),
+            callback=self.parse_catalog,
+            cb_kwargs={"page_number": page_number},
+            headers={
+                "Accept": "text/x-component",
+                "Content-Type": "text/plain;charset=UTF-8",
+                "Next-Action": self.catalog_action_id,
+                "Origin": "https://vbpl.vn",
+                "Referer": CATALOG_URL,
+            },
+        )
+
+    def parse_catalog(self, response, page_number):
+        catalog = unwrap_catalog(response.text)
+        if not catalog:
+            retry_times = response.meta.get("invalid_response_retries", 0)
+            if retry_times < 3:
+                self.logger.warning(
+                    "Retrying invalid catalog page %d (%d/3)",
+                    page_number,
+                    retry_times + 1,
+                )
+                yield response.request.replace(
+                    dont_filter=True,
+                    meta={**response.meta, "invalid_response_retries": retry_times + 1},
+                )
+                return
+            self.logger.error(
+                "Could not parse catalog page %d after 3 retries. "
+                "The catalog action ID may have changed.",
+                page_number,
             )
+            return
 
-    def _request_if_new(self, item_id):
-        """Return a Request for item_id if not already seen, else None."""
-        if item_id not in self.seen_ids:
-            self.seen_ids.add(item_id)
-            return scrapy.Request(
-                METADATA_URL_TEMPLATE.format(item_id),
-                callback=self.parse_metadata,
-                cb_kwargs={"doc_id": item_id, "content_html": None},
+        if page_number == 1:
+            total = int(catalog.get("total") or 0)
+            total_page_count = math.ceil(total / self.page_size)
+            page_count = total_page_count
+            if self.max_pages:
+                page_count = min(page_count, self.max_pages)
+            self.logger.info(
+                "Full crawl discovered %d documents; scheduling %d of %d catalog pages",
+                total,
+                page_count,
+                total_page_count,
             )
+            for next_page in range(2, page_count + 1):
+                yield self._catalog_request(next_page)
 
-    @staticmethod
-    def clean_text(extracted_data):
-        """Helper to clean up whitespace, tabs, and newlines from HTML text."""
-        if not extracted_data:
+        for item in catalog["items"]:
+            request = self._request_if_new(item.get("id"), catalog_item=item)
+            if request:
+                yield request
+
+    def _request_if_new(self, item_id, catalog_item=None):
+        item_id = str(item_id)
+        if not item_id or item_id in self.seen_ids:
             return None
-        if isinstance(extracted_data, str):
-            return extracted_data.strip()
-
-        cleaned = [text.strip() for text in extracted_data if text.strip()]
-        return " ".join(cleaned) if cleaned else None
-
-    def _get_table_value(self, response, label_name, offset=1):
-        """Helper to extract values from the metadata table based on the label."""
-        xpath_query = f'//td[contains(text(), "{label_name}")]/following-sibling::td[{offset}]//text()'
-        return self.clean_text(response.xpath(xpath_query).getall())
-
-    def parse_metadata(self, response, doc_id, content_html=None):
-        """Extract metadata and continue to relationship page for the same document."""
-        if "vbpq-thuoctinh.aspx" in response.url:
-            title = self.clean_text(
-                response.xpath(
-                    '(//div[@class="vbProperties"]//td[@class="title"])[1]//text()'
-                ).getall()
-            )
+        self.seen_ids.add(item_id)
+        return scrapy.Request(
+            DOCUMENT_URL_TEMPLATE.format(item_id),
+            callback=self.parse_document,
+            cb_kwargs={"doc_id": item_id, "catalog_item": catalog_item},
+            headers={"Accept": "application/json", "Referer": "https://vbpl.vn/"},
+            meta={"handle_httpstatus_all": True},
+        )
 
-            if title:
-                item_data = {
-                    "id": doc_id,
-                    "title": title,
-                    "so_ky_hieu": self._get_table_value(response, "Số ký hiệu"),
-                    "ngay_ban_hanh": self._get_table_value(response, "Ngày ban hành"),
-                    "loai_van_ban": self._get_table_value(response, "Loại văn bản"),
-                    "ngay_co_hieu_luc": self._get_table_value(
-                        response, "Ngày có hiệu lực"
-                    ),
-                    "ngay_het_hieu_luc": self._get_table_value(
-                        response, "Ngày hết hiệu lực"
-                    ),
-                    "nguon_thu_thap": self._get_table_value(
-                        response, "Nguồn thu thập"
-                    ),
-                    "ngay_dang_cong_bao": self._get_table_value(
-                        response, "Ngày đăng công báo"
-                    ),
-                    "nganh": self._get_table_value(response, "Ngành"),
-                    "linh_vuc": self._get_table_value(response, "Lĩnh vực"),
-                    "co_quan_ban_hanh": self._get_table_value(
-                        response, "Cơ quan ban hành"
-                    ),
-                    "chuc_danh": self._get_table_value(
-                        response, "Cơ quan ban hành", offset=2
-                    ),
-                    "nguoi_ky": self._get_table_value(
-                        response, "Cơ quan ban hành", offset=3
-                    ),
-                    "pham_vi": self._get_table_value(response, "Phạm vi"),
-                    "thong_tin_ap_dung": self._get_table_value(
-                        response, "Thông tin áp dụng"
-                    ),
-                    "tinh_trang_hieu_luc": self.clean_text(
-                        response.xpath(
-                            '//div[@class="vbInfo"]//li[@class="red"]/text()'
-                        ).get()
-                    ),
-                    "content": content_html,
-                }
-
-                # Fetch the relationship graph block for linked documents.
-                yield scrapy.Request(
-                    url=LUOCDO_URL_TEMPLATE.format(doc_id),
-                    callback=self.parse_luocdo,
-                    cb_kwargs={"item_data": item_data},
+    def parse_document(self, response, doc_id, catalog_item=None):
+        """Extract one API document and follow its linked document IDs."""
+        if response.status >= 400:
+            if catalog_item:
+                yield self._catalog_fallback(
+                    catalog_item, f"catalog_only_http_{response.status}"
                 )
             else:
-                self.logger.debug("Skipping %s: missing document title", doc_id)
-        else:
-            self.logger.debug("Skipping non-metadata page: %s", response.url)
-
-    def parse_luocdo(self, response, item_data):
-        """Step 3: Extract document relationships and yield the final item."""
-        if "vbpq-luocdo.aspx" in response.url:
-            relationships = {}
-            blocks = response.xpath('//div[contains(@class, "luocdo")]')
-
-            for block in blocks:
-                title_nodes = block.xpath(
-                    './/div[starts-with(@class, "title")]//text()'
-                ).getall()
-                raw_title = " ".join(
-                    [text.strip() for text in title_nodes if text.strip() != "\xa0"]
+                self.logger.error("Skipping %s after HTTP %d", doc_id, response.status)
+            return
+
+        try:
+            document = unwrap_document(response.json())
+        except ValueError:
+            document = None
+
+        if not document:
+            retry_times = response.meta.get("invalid_response_retries", 0)
+            if retry_times < 3:
+                self.logger.warning(
+                    "Retrying invalid document %s (%d/3)", doc_id, retry_times + 1
                 )
-                rel_title = re.sub(r"\s*\(\d+\)$", "", raw_title).strip()
-
-                doc_items = block.xpath('.//div[@class="content"]//li')
-                if not doc_items:
-                    continue
-
-                doc_list = []
-                for doc in doc_items:
-                    doc_href = doc.xpath("./a[1]/@href").get()
-                    if doc_href and doc_href != "#":
-                        parsed_href = urlparse(doc_href)
-                        query_params = parse_qs(parsed_href.query)
-                        item_ids = query_params.get("ItemID")
-                        if item_ids:
-                            doc_list.append(item_ids[0])
-
-                if doc_list:
-                    relationships[rel_title] = doc_list
-
-            item_data["relationships"] = relationships
-            yield item_data
-
-            for doc_ids in relationships.values():
-                for doc_id in doc_ids:
-                    req = self._request_if_new(doc_id)
-                    if req:
-                        yield req
-        else:
-            self.logger.debug("Skipping non-luocdo page: %s", response.url)
+                yield response.request.replace(
+                    dont_filter=True,
+                    meta={**response.meta, "invalid_response_retries": retry_times + 1},
+                )
+                return
+            self.logger.error("Skipping %s after 3 invalid API responses", doc_id)
+            if catalog_item:
+                yield self._catalog_fallback(catalog_item, "catalog_only_invalid_detail")
+            return
+
+        issues = document.get("documentIssues") or []
+        majors = document.get("documentMajors") or []
+        fields = document.get("documentFields") or []
+        references = document.get("references") or []
+
+        relationships = defaultdict(list)
+        linked_ids = []
+        for reference in references:
+            target = reference.get("targetDocument") or {}
+            target_id = target.get("id")
+            if not target_id:
+                continue
+            target_id = str(target_id)
+            relationship = REFERENCE_TYPES.get(
+                reference.get("referenceType"),
+                f"Loại quan hệ {reference.get('referenceType')}",
+            )
+            if target_id not in relationships[relationship]:
+                relationships[relationship].append(target_id)
+            linked_ids.append(target_id)
+
+        agency = join_unique(issue.get("agencyName") for issue in issues)
+        if not agency:
+            agency = document.get("agencyName")
+
+        yield {
+            "id": str(document.get("id") or doc_id),
+            "title": document.get("title"),
+            "so_ky_hieu": document.get("docNum"),
+            "ngay_ban_hanh": format_date(document.get("issueDate")),
+            "loai_van_ban": (document.get("docType") or {}).get("name"),
+            "ngay_co_hieu_luc": format_date(document.get("effFrom")),
+            "ngay_het_hieu_luc": format_date(document.get("effTo")),
+            "nguon_thu_thap": None,
+            "ngay_dang_cong_bao": format_date(document.get("publicDate")),
+            "nganh": join_unique(major.get("name") for major in majors),
+            "linh_vuc": join_unique(field.get("name") for field in fields),
+            "co_quan_ban_hanh": agency,
+            "chuc_danh": join_unique(issue.get("jobTitleName") for issue in issues),
+            "nguoi_ky": join_unique(issue.get("personName") for issue in issues),
+            "pham_vi": (
+                "Trung ương"
+                if document.get("isLw") is True
+                else "Địa phương"
+                if document.get("isLw") is False
+                else None
+            ),
+            "thong_tin_ap_dung": None,
+            "tinh_trang_hieu_luc": (document.get("effStatus") or {}).get("name"),
+            "content": (document.get("documentContent") or {}).get("content"),
+            "relationships": dict(relationships),
+        }
+
+        if not self.full:
+            for linked_id in linked_ids:
+                request = self._request_if_new(linked_id)
+                if request:
+                    yield request
+
+    @staticmethod
+    def _catalog_fallback(document, crawl_status):
+        majors = document.get("documentMajors") or []
+        return {
+            "id": str(document.get("id")),
+            "title": document.get("title"),
+            "so_ky_hieu": document.get("docNum"),
+            "ngay_ban_hanh": format_date(document.get("issueDate")),
+            "loai_van_ban": (document.get("docType") or {}).get("name"),
+            "ngay_co_hieu_luc": format_date(document.get("effFrom")),
+            "ngay_het_hieu_luc": format_date(document.get("effTo")),
+            "nguon_thu_thap": None,
+            "ngay_dang_cong_bao": format_date(document.get("publicDate")),
+            "nganh": join_unique(major.get("name") for major in majors),
+            "linh_vuc": None,
+            "co_quan_ban_hanh": document.get("agencyName"),
+            "chuc_danh": None,
+            "nguoi_ky": None,
+            "pham_vi": (
+                "Trung ương"
+                if document.get("isLw") is True
+                else "Địa phương"
+                if document.get("isLw") is False
+                else None
+            ),
+            "thong_tin_ap_dung": None,
+            "tinh_trang_hieu_luc": (document.get("effStatus") or {}).get("name"),
+            "content": None,
+            "relationships": {},
+            "crawl_status": crawl_status,
+        }

crawler/vbpl/spiders/vbpl_content.py

@@ -1,43 +0,0 @@
-from pathlib import Path
-
-import scrapy
-
-
-class VbplSpider(scrapy.Spider):
-    """Crawl VBPL content pages and extract HTML content."""
-
-    name = "vbpl_content"
-
-    def __init__(self, seed_file=None, seed_ids="1", *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        if seed_file:
-            self.seed_ids = [
-                line.strip()
-                for line in Path(seed_file).read_text(encoding="utf-8").splitlines()
-                if line.strip()
-            ]
-        else:
-            self.seed_ids = [item_id.strip() for item_id in str(seed_ids).split(",")]
-
-    def start_requests(self):
-        """Start crawling from seed IDs."""
-        for item_id in self.seed_ids:
-            yield scrapy.Request(
-                f"https://vbpl.vn/tw/Pages/vbpq-print.aspx?ItemID={item_id}",
-                callback=self.parse,
-                cb_kwargs={"doc_id": item_id},
-            )
-
-    def parse(self, response, doc_id):
-        """Extract content from #content element."""
-        # Skip if URL was redirected (not the vbpq-print URL anymore)
-        if "vbpq-print.aspx" not in response.url:
-            return
-
-        content_html = response.css("#content").get()
-        # Only yield if content is not empty
-        if content_html and content_html.strip():
-            yield {
-                "id": doc_id,
-                "content_html": content_html,
-            }

data/content.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2db77423942fda0fb9fd422d0e95194450237fe6bc9663571db2b828dbd2b289
-size 411822717
+oid sha256:36127fdd1bfb0129cb80447b427ff236395c7ab8c75f822a9975c872afd62b7c
+size 787193691

data/metadata.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:89913874a90dc4adc4b4ef40356716713cdf15bac756b8e6662b598ecff7b65d
-size 14081647
+oid sha256:72dbb208c4d5d9f05c1294818c4175603ecc8f853f8745ca35aef7786c0e2e0a
+size 15335252

data/relationships.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:53d9a2e7205c771b72517c82096a1418eafea92e310f5a98bb0a23d8adfa138c
-size 4066078
+oid sha256:2cdb628b4dfdc92e33d234785f80378d0b99418c7711adcbe6402ade98b57ffb
+size 9436116