Add dataset card and scripts

README.md

@@ -1,32 +1,81 @@
 ---
-dataset_info:
-  features:
-  - name: id
-    dtype: string
-  - name: filename
-    dtype: string
-  - name: title
-    dtype: string
-  - name: type
-    dtype: string
-  - name: content
-    dtype: string
-  - name: content_length
-    dtype: int32
-  splits:
-  - name: '2021'
-    num_bytes: 14282751
-    num_examples: 110
-  - name: '2026'
-    num_bytes: 32429305
-    num_examples: 318
-  download_size: 13663651
-  dataset_size: 46712056
-configs:
-- config_name: default
-  data_files:
-  - split: '2021'
-    path: data/2021-*
-  - split: '2026'
-    path: data/2026-*
+language:
+  - vi
+license: mit
+size_categories:
+  - 100<n<1K
+task_categories:
+  - text-generation
+  - text-classification
+tags:
+  - legal
+  - vietnamese
+  - law
+  - vietnam
+  - corpus
+  - legislation
+pretty_name: Vietnamese Legal Corpus
 ---
+
+# Vietnamese Legal Corpus (UTS_VLC)
+
+A comprehensive dataset of Vietnamese laws and legal codes.
+
+## Dataset Description
+
+This dataset contains 318 Vietnamese legal documents including:
+- **6 Codes (Bo luat)**: Civil Code, Criminal Code, Labor Code, etc.
+- **312 Laws (Luat)**: Various laws from 1945 to 2024
+
+## Splits
+
+| Split | Documents | Description |
+|-------|-----------|-------------|
+| 2026  | 318       | Full corpus as of January 2026 |
+
+## Features
+
+- `id`: Document identifier
+- `filename`: Source filename
+- `title`: Vietnamese title
+- `title_en`: English title
+- `type`: "code" or "law"
+- `year`: Year of enactment
+- `document_number`: Official document number
+- `effective_date`: Date when law became effective
+- `status`: Current status (Active/Amended/Repealed)
+- `url`: Source URL
+- `has_content`: Whether full text is available
+- `content`: Full text content
+- `content_length`: Character count
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+# Load the 2026 split
+ds = load_dataset("undertheseanlp/UTS_VLC", split="2026")
+
+# Filter only documents with content
+ds_with_content = ds.filter(lambda x: x["has_content"])
+
+# Get all codes
+codes = ds.filter(lambda x: x["type"] == "code")
+```
+
+## License
+
+MIT License
+
+## Citation
+
+```bibtex
+@dataset{uts_vlc_2026,
+  title={Vietnamese Legal Corpus},
+  author={Underthesea NLP},
+  year={2026},
+  publisher={Hugging Face},
+  url={https://huggingface.co/datasets/undertheseanlp/UTS_VLC}
+}
+```

scripts/README.md

@@ -0,0 +1,80 @@
+# VLC Downloader
+
+Vietnamese Legal Corpus Downloader - Downloads laws and codes from thuvienphapluat.vn
+
+## Setup
+
+```bash
+cd ~/Downloads/vlc-2026/scripts
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+## Usage
+
+### Download laws from database to markdown files
+
+```bash
+# Basic download (metadata only)
+uv run python downloader.py download
+
+# With full content from web
+uv run python downloader.py download --fetch-content
+
+# With custom delay and limit
+uv run python downloader.py download --fetch-content --delay 2.0 --limit 10
+```
+
+### Show statistics
+
+```bash
+uv run python downloader.py stats
+```
+
+### List downloaded files
+
+```bash
+uv run python downloader.py list-files
+```
+
+## Output Structure
+
+```
+vlc-2026/
+├── data/
+│   ├── codes/
+│   │   └── 2015/
+│   │       ├── bo-luat-dan-su.md
+│   │       ├── bo-luat-hinh-su.md
+│   │       └── ...
+│   └── laws/
+│       ├── 2022/
+│       ├── 2023/
+│       ├── 2024/
+│       └── 2025/
+├── scripts/
+│   ├── pyproject.toml
+│   ├── downloader.py
+│   └── README.md
+├── vietnam_laws.sqlite
+└── REFERENCES.md
+```
+
+## Markdown Front Matter
+
+Each file includes YAML front matter:
+
+```yaml
+---
+title: Luật Bảo vệ dữ liệu cá nhân
+title_en: Personal Data Protection Law
+type: law
+year: 2025
+document_number: 91/2025/QH15
+effective_date: 2026-01-01
+status: Active
+url: https://thuvienphapluat.vn/...
+downloaded_at: 2026-01-24T10:30:00
+---
+```

scripts/analyze.py

@@ -0,0 +1,438 @@
+#!/usr/bin/env python3
+"""
+Analyze downloaded Vietnamese Legal Corpus files
+"""
+
+import re
+from pathlib import Path
+from collections import defaultdict
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+console = Console()
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+
+
+def parse_front_matter(content: str) -> dict:
+    """Parse YAML front matter from markdown file."""
+    metadata = {}
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            for line in parts[1].strip().split("\n"):
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    value = value.strip().strip('"')
+                    metadata[key.strip()] = value
+    return metadata
+
+
+def analyze_file(filepath: Path) -> dict:
+    """Analyze a single law file."""
+    content = filepath.read_text(encoding="utf-8")
+    size = filepath.stat().st_size
+
+    metadata = parse_front_matter(content)
+
+    # Check if content exists (after front matter)
+    parts = content.split("---", 2)
+    body = parts[2] if len(parts) >= 3 else ""
+
+    has_content = len(body.strip()) > 200 and "*Nội dung chưa được tải xuống.*" not in body
+
+    return {
+        "filename": filepath.name,
+        "title": metadata.get("title", "Unknown"),
+        "type": metadata.get("type", "unknown"),
+        "year": metadata.get("year", "unknown"),
+        "document_number": metadata.get("document_number", ""),
+        "url": metadata.get("url", ""),
+        "size": size,
+        "has_content": has_content,
+        "content_length": len(body.strip()),
+    }
+
+
+@click.group()
+def cli():
+    """Analyze VLC corpus files."""
+    pass
+
+
+@cli.command()
+def summary():
+    """Show summary statistics."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+
+    stats = {
+        "total": len(files),
+        "with_content": 0,
+        "without_content": 0,
+        "codes": 0,
+        "laws": 0,
+        "total_size": 0,
+        "by_year": defaultdict(int),
+    }
+
+    failed = []
+
+    for f in files:
+        info = analyze_file(f)
+        stats["total_size"] += info["size"]
+
+        if info["type"] == "code":
+            stats["codes"] += 1
+        else:
+            stats["laws"] += 1
+
+        stats["by_year"][info["year"]] += 1
+
+        if info["has_content"]:
+            stats["with_content"] += 1
+        else:
+            stats["without_content"] += 1
+            failed.append(info)
+
+    # Print summary
+    console.print("[bold blue]VLC Corpus Analysis[/bold blue]\n")
+
+    table = Table(title="Summary")
+    table.add_column("Metric", style="cyan")
+    table.add_column("Value", style="green")
+
+    table.add_row("Total files", str(stats["total"]))
+    table.add_row("Codes (Bộ luật)", str(stats["codes"]))
+    table.add_row("Laws (Luật)", str(stats["laws"]))
+    table.add_row("With content", f"{stats['with_content']} ✓")
+    table.add_row("Without content", f"{stats['without_content']} ✗")
+    table.add_row("Success rate", f"{stats['with_content']/stats['total']*100:.1f}%")
+    table.add_row("Total size", f"{stats['total_size']/1024/1024:.1f} MB")
+
+    console.print(table)
+
+    # By year
+    console.print("\n[bold]By Year:[/bold]")
+    for year in sorted(stats["by_year"].keys(), reverse=True)[:10]:
+        console.print(f"  {year}: {stats['by_year'][year]}")
+
+    # Failed files
+    if failed:
+        console.print(f"\n[bold red]Files without content ({len(failed)}):[/bold red]")
+        for info in failed:
+            console.print(f"  - {info['filename']}")
+            console.print(f"    Title: {info['title']}")
+            console.print(f"    Doc#: {info['document_number']}")
+
+
+@cli.command()
+def failed():
+    """List files that failed to download."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+
+    table = Table(title="Files Without Content")
+    table.add_column("#", style="dim")
+    table.add_column("Filename", style="cyan")
+    table.add_column("Title", style="white")
+    table.add_column("Year", style="green")
+    table.add_column("Size", style="yellow")
+
+    count = 0
+    for f in sorted(files):
+        info = analyze_file(f)
+        if not info["has_content"]:
+            count += 1
+            table.add_row(
+                str(count),
+                info["filename"],
+                info["title"][:40] + "..." if len(info["title"]) > 40 else info["title"],
+                str(info["year"]),
+                f"{info['size']} B"
+            )
+
+    if count > 0:
+        console.print(table)
+        console.print(f"\n[red]Total: {count} files without content[/red]")
+    else:
+        console.print("[green]All files have content![/green]")
+
+
+@cli.command()
+def success():
+    """List files that were downloaded successfully."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+
+    table = Table(title="Successfully Downloaded Files")
+    table.add_column("#", style="dim")
+    table.add_column("Filename", style="cyan")
+    table.add_column("Title", style="white")
+    table.add_column("Size", style="green")
+
+    count = 0
+    for f in sorted(files, key=lambda x: x.stat().st_size, reverse=True):
+        info = analyze_file(f)
+        if info["has_content"]:
+            count += 1
+            if count <= 20:  # Show top 20
+                table.add_row(
+                    str(count),
+                    info["filename"],
+                    info["title"][:50] + "..." if len(info["title"]) > 50 else info["title"],
+                    f"{info['size']/1024:.1f} KB"
+                )
+
+    console.print(table)
+    if count > 20:
+        console.print(f"\n... and {count - 20} more files")
+    console.print(f"\n[green]Total: {count} files with content[/green]")
+
+
+@cli.command()
+@click.argument("pattern", default="")
+def search(pattern: str):
+    """Search files by name or title."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+    pattern = pattern.lower()
+
+    results = []
+    for f in files:
+        info = analyze_file(f)
+        if pattern in info["filename"].lower() or pattern in info["title"].lower():
+            results.append(info)
+
+    if results:
+        table = Table(title=f"Search Results: '{pattern}'")
+        table.add_column("Filename", style="cyan")
+        table.add_column("Title", style="white")
+        table.add_column("Content", style="green")
+        table.add_column("Size", style="yellow")
+
+        for info in results:
+            table.add_row(
+                info["filename"],
+                info["title"][:40],
+                "✓" if info["has_content"] else "✗",
+                f"{info['size']/1024:.1f} KB"
+            )
+
+        console.print(table)
+    else:
+        console.print(f"[yellow]No files found matching '{pattern}'[/yellow]")
+
+
+REQUIRED_FIELDS = ["title", "type", "year", "document_number"]
+OPTIONAL_FIELDS = ["title_en", "effective_date", "status", "url", "downloaded_at"]
+
+
+def validate_front_matter(filepath: Path) -> dict:
+    """Validate front matter of a file and return issues."""
+    content = filepath.read_text(encoding="utf-8")
+    issues = []
+    metadata = {}
+
+    # Check if file starts with front matter
+    if not content.startswith("---"):
+        issues.append("Missing front matter (no opening ---)")
+        return {"filename": filepath.name, "issues": issues, "metadata": metadata}
+
+    parts = content.split("---", 2)
+    if len(parts) < 3:
+        issues.append("Invalid front matter (no closing ---)")
+        return {"filename": filepath.name, "issues": issues, "metadata": metadata}
+
+    # Parse front matter
+    for line in parts[1].strip().split("\n"):
+        if ":" in line:
+            key, value = line.split(":", 1)
+            key = key.strip()
+            value = value.strip().strip('"')
+            metadata[key] = value
+
+    # Check required fields
+    for field in REQUIRED_FIELDS:
+        if field not in metadata:
+            issues.append(f"Missing required field: {field}")
+        elif not metadata[field] or metadata[field] in ("Unknown", "unknown", ""):
+            issues.append(f"Empty or invalid value for: {field}")
+
+    # Validate type field
+    if metadata.get("type") and metadata["type"] not in ("code", "law"):
+        issues.append(f"Invalid type: {metadata['type']} (should be 'code' or 'law')")
+
+    # Validate year field
+    year = metadata.get("year", "")
+    if year and not year.isdigit():
+        issues.append(f"Invalid year format: {year}")
+    elif year and (int(year) < 1945 or int(year) > 2030):
+        issues.append(f"Year out of range: {year}")
+
+    # Check filename matches metadata
+    expected_prefix = "code" if metadata.get("type") == "code" else "law"
+    if not filepath.name.startswith(f"{expected_prefix}-"):
+        issues.append(f"Filename prefix mismatch: expected '{expected_prefix}-'")
+
+    if year and f"-{year}-" not in filepath.name:
+        issues.append(f"Year in filename doesn't match metadata: {year}")
+
+    return {"filename": filepath.name, "issues": issues, "metadata": metadata}
+
+
+@cli.command()
+def validate():
+    """Validate front matter of all files."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+    invalid_files = []
+
+    for f in sorted(files):
+        result = validate_front_matter(f)
+        if result["issues"]:
+            invalid_files.append(result)
+
+    if invalid_files:
+        table = Table(title="Files with Invalid Front Matter")
+        table.add_column("#", style="dim")
+        table.add_column("Filename", style="cyan")
+        table.add_column("Issues", style="red")
+
+        for i, item in enumerate(invalid_files, 1):
+            table.add_row(
+                str(i),
+                item["filename"],
+                "\n".join(item["issues"])
+            )
+
+        console.print(table)
+        console.print(f"\n[red]Total: {len(invalid_files)} files with issues[/red]")
+    else:
+        console.print("[green]All files have valid front matter![/green]")
+
+    # Summary
+    console.print(f"\n[bold]Validation Summary:[/bold]")
+    console.print(f"  Total files: {len(files)}")
+    console.print(f"  Valid: {len(files) - len(invalid_files)}")
+    console.print(f"  Invalid: {len(invalid_files)}")
+
+
+@cli.command()
+@click.argument("filename", required=False)
+def inspect(filename: str):
+    """Inspect front matter of a specific file or show all fields."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    if filename:
+        # Inspect single file
+        filepath = DATA_DIR / filename
+        if not filepath.exists():
+            # Try to find matching file
+            matches = list(DATA_DIR.glob(f"*{filename}*"))
+            if matches:
+                filepath = matches[0]
+            else:
+                console.print(f"[red]File not found: {filename}[/red]")
+                return
+
+        result = validate_front_matter(filepath)
+        console.print(f"\n[bold]File: {result['filename']}[/bold]\n")
+
+        table = Table(title="Front Matter")
+        table.add_column("Field", style="cyan")
+        table.add_column("Value", style="white")
+        table.add_column("Status", style="green")
+
+        for field in REQUIRED_FIELDS + OPTIONAL_FIELDS:
+            value = result["metadata"].get(field, "")
+            if field in REQUIRED_FIELDS:
+                status = "✓" if value and value not in ("Unknown", "unknown") else "✗ required"
+            else:
+                status = "✓" if value else "-"
+            table.add_row(field, str(value)[:50], status)
+
+        console.print(table)
+
+        if result["issues"]:
+            console.print("\n[bold red]Issues:[/bold red]")
+            for issue in result["issues"]:
+                console.print(f"  - {issue}")
+    else:
+        # Show field statistics
+        files = list(DATA_DIR.glob("*.md"))
+        field_stats = defaultdict(int)
+
+        for f in files:
+            result = validate_front_matter(f)
+            for field in REQUIRED_FIELDS + OPTIONAL_FIELDS:
+                if result["metadata"].get(field):
+                    field_stats[field] += 1
+
+        table = Table(title="Front Matter Field Statistics")
+        table.add_column("Field", style="cyan")
+        table.add_column("Present", style="green")
+        table.add_column("Missing", style="red")
+        table.add_column("Coverage", style="yellow")
+
+        for field in REQUIRED_FIELDS + OPTIONAL_FIELDS:
+            present = field_stats[field]
+            missing = len(files) - present
+            coverage = f"{present/len(files)*100:.1f}%"
+            req = " (required)" if field in REQUIRED_FIELDS else ""
+            table.add_row(f"{field}{req}", str(present), str(missing), coverage)
+
+        console.print(table)
+
+
+@cli.command()
+def export_failed():
+    """Export failed files to retry list."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    files = list(DATA_DIR.glob("*.md"))
+
+    failed = []
+    for f in files:
+        info = analyze_file(f)
+        if not info["has_content"]:
+            failed.append({
+                "filename": info["filename"],
+                "title": info["title"],
+                "document_number": info["document_number"],
+            })
+
+    if failed:
+        output = DATA_DIR.parent / "failed_downloads.txt"
+        with open(output, "w", encoding="utf-8") as f:
+            for item in failed:
+                f.write(f"{item['filename']}\t{item['title']}\t{item['document_number']}\n")
+
+        console.print(f"[green]Exported {len(failed)} failed files to {output}[/green]")
+    else:
+        console.print("[green]No failed files to export[/green]")
+
+
+if __name__ == "__main__":
+    cli()

scripts/browser_downloader.py

@@ -0,0 +1,250 @@
+#!/usr/bin/env python3
+"""
+Vietnamese Legal Corpus Browser Downloader
+Uses Playwright to download laws from thuvienphapluat.vn
+"""
+
+import re
+import sqlite3
+import asyncio
+from pathlib import Path
+from datetime import datetime
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+console = Console()
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+DB_PATH = Path(__file__).parent.parent / "vietnam_laws.sqlite"
+
+# Known URL patterns for major codes
+KNOWN_URLS = {
+    "91/2015/QH13": "https://thuvienphapluat.vn/van-ban/Quyen-dan-su/Bo-luat-dan-su-2015-296215.aspx",
+    "92/2015/QH13": "https://thuvienphapluat.vn/van-ban/Thu-tuc-To-tung/Bo-luat-to-tung-dan-su-2015-296861.aspx",
+    "100/2015/QH13": "https://thuvienphapluat.vn/van-ban/Trach-nhiem-hinh-su/Bo-luat-hinh-su-2015-296661.aspx",
+    "101/2015/QH13": "https://thuvienphapluat.vn/van-ban/Trach-nhiem-hinh-su/Bo-luat-to-tung-hinh-su-2015-296884.aspx",
+    "95/2015/QH13": "https://thuvienphapluat.vn/van-ban/Giao-thong-Van-tai/Bo-luat-hang-hai-Viet-Nam-2015-298822.aspx",
+    "45/2019/QH14": "https://thuvienphapluat.vn/van-ban/Lao-dong-Tien-luong/Bo-luat-Lao-dong-2019-428584.aspx",
+}
+
+
+def slugify(text: str) -> str:
+    """Convert Vietnamese text to slug."""
+    vietnamese_map = {
+        'à': 'a', 'á': 'a', 'ả': 'a', 'ã': 'a', 'ạ': 'a',
+        'ă': 'a', 'ằ': 'a', 'ắ': 'a', 'ẳ': 'a', 'ẵ': 'a', 'ặ': 'a',
+        'â': 'a', 'ầ': 'a', 'ấ': 'a', 'ẩ': 'a', 'ẫ': 'a', 'ậ': 'a',
+        'đ': 'd',
+        'è': 'e', 'é': 'e', 'ẻ': 'e', 'ẽ': 'e', 'ẹ': 'e',
+        'ê': 'e', 'ề': 'e', 'ế': 'e', 'ể': 'e', 'ễ': 'e', 'ệ': 'e',
+        'ì': 'i', 'í': 'i', 'ỉ': 'i', 'ĩ': 'i', 'ị': 'i',
+        'ò': 'o', 'ó': 'o', 'ỏ': 'o', 'õ': 'o', 'ọ': 'o',
+        'ô': 'o', 'ồ': 'o', 'ố': 'o', 'ổ': 'o', 'ỗ': 'o', 'ộ': 'o',
+        'ơ': 'o', 'ờ': 'o', 'ớ': 'o', 'ở': 'o', 'ỡ': 'o', 'ợ': 'o',
+        'ù': 'u', 'ú': 'u', 'ủ': 'u', 'ũ': 'u', 'ụ': 'u',
+        'ư': 'u', 'ừ': 'u', 'ứ': 'u', 'ử': 'u', 'ữ': 'u', 'ự': 'u',
+        'ỳ': 'y', 'ý': 'y', 'ỷ': 'y', 'ỹ': 'y', 'ỵ': 'y',
+    }
+    text = text.lower()
+    for viet, ascii_char in vietnamese_map.items():
+        text = text.replace(viet, ascii_char)
+    text = re.sub(r'[^a-z0-9]+', '-', text)
+    text = re.sub(r'-+', '-', text)
+    return text.strip('-')
+
+
+def create_front_matter(metadata: dict) -> str:
+    """Create YAML front matter."""
+    lines = ["---"]
+    for key, value in metadata.items():
+        if value is not None:
+            if isinstance(value, str) and ('\n' in value or ':' in value or '"' in value):
+                value = value.replace('"', '\\"').replace('\n', ' ')
+                lines.append(f'{key}: "{value}"')
+            else:
+                lines.append(f"{key}: {value}")
+    lines.append("---")
+    return "\n".join(lines)
+
+
+def get_laws_from_db() -> list[dict]:
+    """Get laws from SQLite database."""
+    if not DB_PATH.exists():
+        return []
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+
+    laws = []
+
+    cursor.execute("SELECT * FROM codes")
+    for row in cursor.fetchall():
+        laws.append({
+            "id": f"code-{row['id']}",
+            "type": "code",
+            "name": row["name"],
+            "name_vi": row["name_vi"],
+            "year": row["year"],
+            "document_number": row["document_number"],
+            "effective_date": row["effective_date"],
+            "status": row["status"],
+        })
+
+    cursor.execute("SELECT * FROM laws")
+    for row in cursor.fetchall():
+        laws.append({
+            "id": f"law-{row['id']}",
+            "type": "law",
+            "name": row["name"],
+            "name_vi": row["name_vi"],
+            "year": row["year"],
+            "document_number": row["document_number"],
+            "effective_date": row["effective_date"],
+            "status": row["status"],
+        })
+
+    conn.close()
+    return laws
+
+
+def save_law_file(law: dict, content: str | None = None, url: str | None = None) -> Path:
+    """Save law to markdown file."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    law_type = law.get("type", "law")
+    year = law.get("year", "unknown")
+    name_vi = law.get("name_vi", law.get("name", "unknown"))
+    slug = slugify(name_vi)
+
+    prefix = "code" if law_type == "code" else "law"
+    filename = f"{prefix}-{year}-{slug}.md"
+    filepath = DATA_DIR / filename
+
+    front_matter_data = {
+        "title": law.get("name_vi", law.get("name")),
+        "title_en": law.get("name"),
+        "type": law_type,
+        "year": year,
+        "document_number": law.get("document_number"),
+        "effective_date": law.get("effective_date"),
+        "status": law.get("status", "Active"),
+        "url": url,
+        "downloaded_at": datetime.now().isoformat(),
+    }
+
+    md_content = create_front_matter(front_matter_data)
+    md_content += "\n\n"
+    md_content += f"# {law.get('name_vi', law.get('name'))}\n\n"
+
+    if law.get("name"):
+        md_content += f"**English:** {law['name']}\n\n"
+    if law.get("document_number"):
+        md_content += f"**Số hiệu:** {law['document_number']}\n\n"
+    if law.get("effective_date"):
+        md_content += f"**Ngày hiệu lực:** {law['effective_date']}\n\n"
+
+    if content:
+        md_content += "---\n\n"
+        md_content += content
+    else:
+        md_content += "*Nội dung chưa được tải xuống.*\n"
+
+    filepath.write_text(md_content, encoding="utf-8")
+    return filepath
+
+
+async def download_with_playwright(laws: list[dict], delay: float = 2.0):
+    """Download laws using Playwright."""
+    try:
+        from playwright.async_api import async_playwright
+    except ImportError:
+        console.print("[red]Playwright not installed. Run: uv pip install playwright && playwright install chromium[/red]")
+        return
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        context = await browser.new_context(
+            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+        )
+        page = await context.new_page()
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Downloading...", total=len(laws))
+
+            for law in laws:
+                name = law.get("name_vi", law.get("name", "Unknown"))
+                doc_num = law.get("document_number", "")
+                progress.update(task, description=f"[cyan]{name[:40]}[/cyan]")
+
+                content = None
+                url = KNOWN_URLS.get(doc_num)
+
+                if not url:
+                    # Search on thuvienphapluat.vn
+                    try:
+                        search_url = f"https://thuvienphapluat.vn/page/tim-van-ban.aspx?keyword={doc_num or name}"
+                        await page.goto(search_url, wait_until="networkidle", timeout=30000)
+                        await asyncio.sleep(1)
+
+                        # Find first result link
+                        link = await page.query_selector("a[href*='/van-ban/']")
+                        if link:
+                            url = await link.get_attribute("href")
+                            if url and not url.startswith("http"):
+                                url = f"https://thuvienphapluat.vn{url}"
+                    except Exception as e:
+                        console.print(f"[yellow]Search failed: {name}: {e}[/yellow]")
+
+                if url:
+                    try:
+                        await page.goto(url, wait_until="networkidle", timeout=30000)
+                        await asyncio.sleep(1)
+
+                        # Extract content
+                        content_elem = await page.query_selector(".content1, .toanvancontent, .fulltext")
+                        if content_elem:
+                            content = await content_elem.inner_text()
+                    except Exception as e:
+                        console.print(f"[yellow]Fetch failed: {name}: {e}[/yellow]")
+
+                save_law_file(law, content, url)
+                progress.advance(task)
+                await asyncio.sleep(delay)
+
+        await browser.close()
+
+
+@click.command()
+@click.option("--delay", default=2.0, help="Delay between requests (seconds)")
+@click.option("--limit", default=0, help="Limit number of laws (0 = all)")
+def download(delay: float, limit: int):
+    """Download laws using browser automation."""
+    console.print("[bold blue]VLC Browser Downloader[/bold blue]\n")
+
+    laws = get_laws_from_db()
+    if not laws:
+        console.print("[yellow]No laws in database[/yellow]")
+        return
+
+    if limit > 0:
+        laws = laws[:limit]
+
+    console.print(f"Found [green]{len(laws)}[/green] laws to download")
+    console.print(f"Output: [cyan]{DATA_DIR}[/cyan]\n")
+
+    asyncio.run(download_with_playwright(laws, delay))
+
+    console.print(f"\n[green]Done![/green] Files saved to {DATA_DIR}")
+
+
+if __name__ == "__main__":
+    download()

scripts/downloader.py

@@ -0,0 +1,443 @@
+#!/usr/bin/env python3
+"""
+Vietnamese Legal Corpus Downloader
+Downloads laws and codes from thuvienphapluat.vn
+"""
+
+import re
+import time
+import sqlite3
+from pathlib import Path
+from datetime import datetime
+from urllib.parse import urljoin
+
+import httpx
+import click
+from bs4 import BeautifulSoup
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+console = Console()
+
+BASE_URL = "https://thuvienphapluat.vn"
+SEARCH_URL = "https://thuvienphapluat.vn/page/tim-van-ban.aspx"
+DATA_DIR = Path(__file__).parent.parent / "data"
+DB_PATH = Path(__file__).parent.parent / "vietnam_laws.sqlite"
+
+HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+    "Accept-Language": "vi-VN,vi;q=0.9,en;q=0.8",
+    "Referer": "https://thuvienphapluat.vn/",
+}
+
+
+def slugify(text: str) -> str:
+    """Convert Vietnamese text to slug."""
+    # Vietnamese character mapping
+    vietnamese_map = {
+        'à': 'a', 'á': 'a', 'ả': 'a', 'ã': 'a', 'ạ': 'a',
+        'ă': 'a', 'ằ': 'a', 'ắ': 'a', 'ẳ': 'a', 'ẵ': 'a', 'ặ': 'a',
+        'â': 'a', 'ầ': 'a', 'ấ': 'a', 'ẩ': 'a', 'ẫ': 'a', 'ậ': 'a',
+        'đ': 'd',
+        'è': 'e', 'é': 'e', 'ẻ': 'e', 'ẽ': 'e', 'ẹ': 'e',
+        'ê': 'e', 'ề': 'e', 'ế': 'e', 'ể': 'e', 'ễ': 'e', 'ệ': 'e',
+        'ì': 'i', 'í': 'i', 'ỉ': 'i', 'ĩ': 'i', 'ị': 'i',
+        'ò': 'o', 'ó': 'o', 'ỏ': 'o', 'õ': 'o', 'ọ': 'o',
+        'ô': 'o', 'ồ': 'o', 'ố': 'o', 'ổ': 'o', 'ỗ': 'o', 'ộ': 'o',
+        'ơ': 'o', 'ờ': 'o', 'ớ': 'o', 'ở': 'o', 'ỡ': 'o', 'ợ': 'o',
+        'ù': 'u', 'ú': 'u', 'ủ': 'u', 'ũ': 'u', 'ụ': 'u',
+        'ư': 'u', 'ừ': 'u', 'ứ': 'u', 'ử': 'u', 'ữ': 'u', 'ự': 'u',
+        'ỳ': 'y', 'ý': 'y', 'ỷ': 'y', 'ỹ': 'y', 'ỵ': 'y',
+    }
+
+    text = text.lower()
+    for viet, ascii_char in vietnamese_map.items():
+        text = text.replace(viet, ascii_char)
+
+    # Replace spaces and special chars with hyphens
+    text = re.sub(r'[^a-z0-9]+', '-', text)
+    text = re.sub(r'-+', '-', text)
+    return text.strip('-')
+
+
+def create_front_matter(metadata: dict) -> str:
+    """Create YAML front matter for markdown file."""
+    lines = ["---"]
+    for key, value in metadata.items():
+        if value is not None:
+            if isinstance(value, str) and ('\n' in value or ':' in value or '"' in value):
+                # Multi-line or special chars: use quoted string
+                value = value.replace('"', '\\"')
+                lines.append(f'{key}: "{value}"')
+            else:
+                lines.append(f"{key}: {value}")
+    lines.append("---")
+    return "\n".join(lines)
+
+
+def search_law_url(client: httpx.Client, name_vi: str, doc_number: str | None = None) -> str | None:
+    """Search for a law on thuvienphapluat.vn and return its URL."""
+    try:
+        # Search by document number first if available
+        keyword = doc_number if doc_number else name_vi
+        params = {
+            "keyword": keyword,
+            "type": "0",
+            "match": "True",
+            "area": "0",
+            "status": "0",
+            "signer": "0",
+            "sort": "0",
+            "page": "1",
+        }
+
+        response = client.get(SEARCH_URL, params=params, follow_redirects=True)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "lxml")
+
+        # Find first matching result
+        for item in soup.select(".nqDoc, .doc-item, .search-result-item, [class*='item']"):
+            link = item.select_one("a[href*='/van-ban/']")
+            if link:
+                href = link.get("href", "")
+                if href:
+                    return urljoin(BASE_URL, href)
+
+        # Try alternative selectors
+        for link in soup.select("a[href*='/van-ban/']"):
+            href = link.get("href", "")
+            if href and "/van-ban/" in href:
+                return urljoin(BASE_URL, href)
+
+        return None
+
+    except Exception as e:
+        console.print(f"[yellow]Search failed for {name_vi}: {e}[/yellow]")
+        return None
+
+
+def fetch_law_content(client: httpx.Client, url: str) -> dict | None:
+    """Fetch law content from thuvienphapluat.vn."""
+    try:
+        response = client.get(url, follow_redirects=True)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "lxml")
+
+        # Extract metadata
+        metadata = {
+            "url": url,
+            "downloaded_at": datetime.now().isoformat(),
+        }
+
+        # Title
+        title_elem = soup.select_one("h1.title, .doc-title h1, h1")
+        if title_elem:
+            metadata["title"] = title_elem.get_text(strip=True)
+
+        # Document number
+        doc_num = soup.select_one(".doc-number, .so-hieu")
+        if doc_num:
+            metadata["document_number"] = doc_num.get_text(strip=True)
+
+        # Effective date
+        effective = soup.select_one(".effective-date, .ngay-hieu-luc")
+        if effective:
+            metadata["effective_date"] = effective.get_text(strip=True)
+
+        # Status
+        status = soup.select_one(".doc-status, .tinh-trang")
+        if status:
+            metadata["status"] = status.get_text(strip=True)
+
+        # Issuing body
+        issuer = soup.select_one(".issuing-body, .co-quan-ban-hanh")
+        if issuer:
+            metadata["issuing_body"] = issuer.get_text(strip=True)
+
+        # Main content
+        content_elem = soup.select_one(".doc-content, .noi-dung, .content, article")
+        if content_elem:
+            # Remove scripts and styles
+            for tag in content_elem.select("script, style"):
+                tag.decompose()
+
+            content = content_elem.get_text(separator="\n", strip=True)
+            metadata["content"] = content
+        else:
+            # Fallback: get body text
+            body = soup.find("body")
+            if body:
+                for tag in body.select("script, style, nav, header, footer"):
+                    tag.decompose()
+                metadata["content"] = body.get_text(separator="\n", strip=True)
+
+        return metadata
+
+    except Exception as e:
+        console.print(f"[red]Error fetching {url}: {e}[/red]")
+        return None
+
+
+def fetch_law_list_page(client: httpx.Client, page: int = 1) -> list[dict]:
+    """Fetch list of laws from thuvienphapluat.vn."""
+    url = f"{BASE_URL}/page/tim-van-ban.aspx?keyword=&type=0&match=True&area=0&status=0&signer=0&sort=0&page={page}"
+
+    try:
+        response = client.get(url, follow_redirects=True)
+        response.raise_for_status()
+
+        soup = BeautifulSoup(response.text, "lxml")
+        laws = []
+
+        for item in soup.select(".doc-item, .search-result-item, .item"):
+            law = {}
+
+            link = item.select_one("a[href*='/van-ban/']")
+            if link:
+                law["url"] = urljoin(BASE_URL, link.get("href", ""))
+                law["title"] = link.get_text(strip=True)
+
+            doc_num = item.select_one(".doc-number, .so-hieu")
+            if doc_num:
+                law["document_number"] = doc_num.get_text(strip=True)
+
+            if law.get("url"):
+                laws.append(law)
+
+        return laws
+
+    except Exception as e:
+        console.print(f"[red]Error fetching law list page {page}: {e}[/red]")
+        return []
+
+
+def get_laws_from_db() -> list[dict]:
+    """Get laws from SQLite database."""
+    if not DB_PATH.exists():
+        console.print(f"[yellow]Database not found: {DB_PATH}[/yellow]")
+        return []
+
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+
+    laws = []
+
+    # Get codes
+    cursor.execute("SELECT * FROM codes")
+    for row in cursor.fetchall():
+        laws.append({
+            "id": f"code-{row['id']}",
+            "type": "code",
+            "name": row["name"],
+            "name_vi": row["name_vi"],
+            "year": row["year"],
+            "document_number": row["document_number"],
+            "effective_date": row["effective_date"],
+            "status": row["status"],
+            "url": row["url"],
+        })
+
+    # Get laws
+    cursor.execute("SELECT * FROM laws")
+    for row in cursor.fetchall():
+        laws.append({
+            "id": f"law-{row['id']}",
+            "type": "law",
+            "name": row["name"],
+            "name_vi": row["name_vi"],
+            "year": row["year"],
+            "document_number": row["document_number"],
+            "effective_date": row["effective_date"],
+            "status": row["status"],
+            "url": row["url"],
+        })
+
+    conn.close()
+    return laws
+
+
+def save_law_file(law: dict, content: str | None = None) -> Path:
+    """Save law to markdown file with front matter."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+
+    # Generate filename with year prefix for uniqueness
+    law_type = law.get("type", "law")
+    year = law.get("year", "unknown")
+    name_vi = law.get("name_vi", law.get("name", "unknown"))
+    slug = slugify(name_vi)
+
+    # Prefix: code- or law- with year
+    prefix = "code" if law_type == "code" else "law"
+    filename = f"{prefix}-{year}-{slug}.md"
+    filepath = DATA_DIR / filename
+
+    # Prepare front matter
+    front_matter_data = {
+        "title": law.get("name_vi", law.get("name")),
+        "title_en": law.get("name"),
+        "type": law_type,
+        "year": year,
+        "document_number": law.get("document_number"),
+        "effective_date": law.get("effective_date"),
+        "status": law.get("status", "Active"),
+        "url": law.get("url"),
+        "downloaded_at": datetime.now().isoformat(),
+    }
+
+    # Build markdown content
+    md_content = create_front_matter(front_matter_data)
+    md_content += "\n\n"
+    md_content += f"# {law.get('name_vi', law.get('name'))}\n\n"
+
+    if law.get("name"):
+        md_content += f"**English:** {law['name']}\n\n"
+
+    if law.get("document_number"):
+        md_content += f"**Số hiệu:** {law['document_number']}\n\n"
+
+    if law.get("effective_date"):
+        md_content += f"**Ngày hiệu lực:** {law['effective_date']}\n\n"
+
+    if content:
+        md_content += "## Nội dung\n\n"
+        md_content += content
+    else:
+        md_content += "*Nội dung chưa được tải xuống.*\n"
+
+    filepath.write_text(md_content, encoding="utf-8")
+    return filepath
+
+
+@click.group()
+def cli():
+    """Vietnamese Legal Corpus Downloader"""
+    pass
+
+
+@cli.command()
+@click.option("--fetch-content", is_flag=True, help="Fetch full content from web")
+@click.option("--delay", default=1.0, help="Delay between requests (seconds)")
+@click.option("--limit", default=0, help="Limit number of laws to download (0 = all)")
+def download(fetch_content: bool, delay: float, limit: int):
+    """Download laws from database to markdown files."""
+    console.print("[bold blue]Vietnamese Legal Corpus Downloader[/bold blue]")
+    console.print()
+
+    # Get laws from database
+    laws = get_laws_from_db()
+
+    if not laws:
+        console.print("[yellow]No laws found in database. Please populate the database first.[/yellow]")
+        return
+
+    if limit > 0:
+        laws = laws[:limit]
+
+    console.print(f"Found [green]{len(laws)}[/green] laws/codes to download")
+    console.print(f"Output directory: [cyan]{DATA_DIR}[/cyan]")
+    console.print()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Downloading...", total=len(laws))
+
+        client = httpx.Client(headers=HEADERS, timeout=30.0)
+
+        try:
+            for law in laws:
+                name = law.get("name_vi", law.get("name", "Unknown"))
+                progress.update(task, description=f"[cyan]{name[:40]}[/cyan]")
+
+                content = None
+                url = law.get("url")
+
+                if fetch_content:
+                    # Search for URL if not in database
+                    if not url:
+                        url = search_law_url(
+                            client,
+                            law.get("name_vi", ""),
+                            law.get("document_number")
+                        )
+                        time.sleep(delay)
+
+                    # Fetch content from URL
+                    if url:
+                        law["url"] = url
+                        data = fetch_law_content(client, url)
+                        if data:
+                            content = data.get("content")
+                        time.sleep(delay)
+
+                filepath = save_law_file(law, content)
+                progress.advance(task)
+
+        finally:
+            client.close()
+
+    console.print()
+    console.print(f"[green]Done![/green] Files saved to [cyan]{DATA_DIR}[/cyan]")
+
+
+@cli.command()
+def stats():
+    """Show statistics from database."""
+    laws = get_laws_from_db()
+
+    if not laws:
+        console.print("[yellow]No data in database[/yellow]")
+        return
+
+    codes = [l for l in laws if l["type"] == "code"]
+    law_list = [l for l in laws if l["type"] == "law"]
+
+    console.print("[bold]Vietnamese Legal Corpus Statistics[/bold]")
+    console.print()
+    console.print(f"  Codes (Bộ luật): [green]{len(codes)}[/green]")
+    console.print(f"  Laws (Luật):     [green]{len(law_list)}[/green]")
+    console.print(f"  [bold]Total:           [green]{len(laws)}[/green][/bold]")
+
+    # By year
+    console.print()
+    console.print("[bold]By Year:[/bold]")
+    years = {}
+    for law in laws:
+        year = law.get("year", "Unknown")
+        years[year] = years.get(year, 0) + 1
+
+    for year in sorted(years.keys(), reverse=True)[:10]:
+        console.print(f"  {year}: {years[year]}")
+
+
+@cli.command()
+def list_files():
+    """List downloaded files."""
+    if not DATA_DIR.exists():
+        console.print("[yellow]No data directory found[/yellow]")
+        return
+
+    files = list(DATA_DIR.rglob("*.md"))
+    console.print(f"Found [green]{len(files)}[/green] files in {DATA_DIR}")
+
+    for f in files[:20]:
+        console.print(f"  {f.relative_to(DATA_DIR)}")
+
+    if len(files) > 20:
+        console.print(f"  ... and {len(files) - 20} more")
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

scripts/fast_downloader.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+Fast Vietnamese Legal Corpus Downloader
+Uses Playwright with concurrent downloads
+"""
+
+import re
+import sqlite3
+import asyncio
+from pathlib import Path
+from datetime import datetime
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+
+console = Console()
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+DB_PATH = Path(__file__).parent.parent / "vietnam_laws.sqlite"
+
+
+def slugify(text: str) -> str:
+    vietnamese_map = {
+        'à': 'a', 'á': 'a', 'ả': 'a', 'ã': 'a', 'ạ': 'a',
+        'ă': 'a', 'ằ': 'a', 'ắ': 'a', 'ẳ': 'a', 'ẵ': 'a', 'ặ': 'a',
+        'â': 'a', 'ầ': 'a', 'ấ': 'a', 'ẩ': 'a', 'ẫ': 'a', 'ậ': 'a',
+        'đ': 'd',
+        'è': 'e', 'é': 'e', 'ẻ': 'e', 'ẽ': 'e', 'ẹ': 'e',
+        'ê': 'e', 'ề': 'e', 'ế': 'e', 'ể': 'e', 'ễ': 'e', 'ệ': 'e',
+        'ì': 'i', 'í': 'i', 'ỉ': 'i', 'ĩ': 'i', 'ị': 'i',
+        'ò': 'o', 'ó': 'o', 'ỏ': 'o', 'õ': 'o', 'ọ': 'o',
+        'ô': 'o', 'ồ': 'o', 'ố': 'o', 'ổ': 'o', 'ỗ': 'o', 'ộ': 'o',
+        'ơ': 'o', 'ờ': 'o', 'ớ': 'o', 'ở': 'o', 'ỡ': 'o', 'ợ': 'o',
+        'ù': 'u', 'ú': 'u', 'ủ': 'u', 'ũ': 'u', 'ụ': 'u',
+        'ư': 'u', 'ừ': 'u', 'ứ': 'u', 'ử': 'u', 'ữ': 'u', 'ự': 'u',
+        'ỳ': 'y', 'ý': 'y', 'ỷ': 'y', 'ỹ': 'y', 'ỵ': 'y',
+    }
+    text = text.lower()
+    for viet, ascii_char in vietnamese_map.items():
+        text = text.replace(viet, ascii_char)
+    text = re.sub(r'[^a-z0-9]+', '-', text)
+    return text.strip('-')
+
+
+def get_laws_from_db() -> list[dict]:
+    if not DB_PATH.exists():
+        return []
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    cursor = conn.cursor()
+    laws = []
+
+    cursor.execute("SELECT * FROM codes")
+    for row in cursor.fetchall():
+        laws.append({
+            "type": "code", "name": row["name"], "name_vi": row["name_vi"],
+            "year": row["year"], "document_number": row["document_number"],
+            "effective_date": row["effective_date"], "status": row["status"],
+        })
+
+    cursor.execute("SELECT * FROM laws")
+    for row in cursor.fetchall():
+        laws.append({
+            "type": "law", "name": row["name"], "name_vi": row["name_vi"],
+            "year": row["year"], "document_number": row["document_number"],
+            "effective_date": row["effective_date"], "status": row["status"],
+        })
+
+    conn.close()
+    return laws
+
+
+def get_filepath(law: dict) -> Path:
+    law_type = law.get("type", "law")
+    year = law.get("year", "unknown")
+    name_vi = law.get("name_vi", law.get("name", "unknown"))
+    slug = slugify(name_vi)
+    prefix = "code" if law_type == "code" else "law"
+    return DATA_DIR / f"{prefix}-{year}-{slug}.md"
+
+
+def needs_download(law: dict) -> bool:
+    filepath = get_filepath(law)
+    if not filepath.exists():
+        return True
+    # Check if file has content (> 1KB)
+    return filepath.stat().st_size < 1000
+
+
+def save_law_file(law: dict, content: str | None = None, url: str | None = None):
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    filepath = get_filepath(law)
+
+    lines = ["---"]
+    lines.append(f"title: {law.get('name_vi', law.get('name'))}")
+    if law.get("name"):
+        lines.append(f"title_en: {law['name']}")
+    lines.append(f"type: {law.get('type', 'law')}")
+    lines.append(f"year: {law.get('year')}")
+    if law.get("document_number"):
+        lines.append(f"document_number: {law['document_number']}")
+    if law.get("effective_date"):
+        lines.append(f"effective_date: {law['effective_date']}")
+    lines.append(f"status: {law.get('status', 'Active')}")
+    if url:
+        lines.append(f'url: "{url}"')
+    lines.append(f'downloaded_at: "{datetime.now().isoformat()}"')
+    lines.append("---\n")
+
+    md = "\n".join(lines)
+    md += f"\n# {law.get('name_vi', law.get('name'))}\n\n"
+    if law.get("document_number"):
+        md += f"**Số hiệu:** {law['document_number']}\n\n"
+    if content:
+        md += "---\n\n" + content
+    else:
+        md += "*Nội dung chưa được tải xuống.*\n"
+
+    filepath.write_text(md, encoding="utf-8")
+
+
+async def download_law(page, law: dict, semaphore: asyncio.Semaphore) -> bool:
+    async with semaphore:
+        name = law.get("name_vi", "")
+        doc_num = law.get("document_number", "")
+
+        try:
+            # Search for law
+            keyword = doc_num if doc_num else name
+            search_url = f"https://thuvienphapluat.vn/page/tim-van-ban.aspx?keyword={keyword}"
+
+            await page.goto(search_url, wait_until="domcontentloaded", timeout=15000)
+            await asyncio.sleep(0.5)
+
+            # Find first result
+            link = await page.query_selector("a[href*='/van-ban/']")
+            if not link:
+                save_law_file(law, None, None)
+                return False
+
+            url = await link.get_attribute("href")
+            if not url.startswith("http"):
+                url = f"https://thuvienphapluat.vn{url}"
+
+            # Go to law page
+            await page.goto(url, wait_until="domcontentloaded", timeout=15000)
+            await asyncio.sleep(0.5)
+
+            # Extract content
+            content = None
+            content_elem = await page.query_selector(".content1, .toanvancontent, .fulltext, #toanvancontent")
+            if content_elem:
+                content = await content_elem.inner_text()
+
+            save_law_file(law, content, url)
+            return True
+
+        except Exception as e:
+            save_law_file(law, None, None)
+            return False
+
+
+async def run_downloads(laws: list[dict], concurrency: int = 5):
+    from playwright.async_api import async_playwright
+
+    async with async_playwright() as p:
+        browser = await p.chromium.launch(headless=True)
+        semaphore = asyncio.Semaphore(concurrency)
+
+        # Create multiple pages
+        pages = []
+        for _ in range(concurrency):
+            context = await browser.new_context(
+                user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
+            )
+            page = await context.new_page()
+            pages.append(page)
+
+        success = 0
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=console,
+        ) as progress:
+            task = progress.add_task("Downloading...", total=len(laws))
+
+            # Process in batches
+            for i in range(0, len(laws), concurrency):
+                batch = laws[i:i + concurrency]
+                tasks = []
+
+                for j, law in enumerate(batch):
+                    page = pages[j % len(pages)]
+                    tasks.append(download_law(page, law, semaphore))
+
+                results = await asyncio.gather(*tasks, return_exceptions=True)
+
+                for r in results:
+                    if r is True:
+                        success += 1
+                    progress.advance(task)
+
+                progress.update(task, description=f"[cyan]Downloaded: {success}/{len(laws)}[/cyan]")
+
+        await browser.close()
+        return success
+
+
+@click.command()
+@click.option("--concurrency", default=5, help="Number of concurrent downloads")
+@click.option("--skip-existing", is_flag=True, help="Skip files that already have content")
+def download(concurrency: int, skip_existing: bool):
+    """Fast parallel download of Vietnamese laws."""
+    console.print("[bold blue]VLC Fast Downloader[/bold blue]\n")
+
+    laws = get_laws_from_db()
+    if not laws:
+        console.print("[yellow]No laws in database[/yellow]")
+        return
+
+    if skip_existing:
+        laws = [l for l in laws if needs_download(l)]
+        console.print(f"[yellow]Skipping already downloaded files[/yellow]")
+
+    console.print(f"Downloading [green]{len(laws)}[/green] laws (concurrency: {concurrency})")
+    console.print(f"Output: [cyan]{DATA_DIR}[/cyan]\n")
+
+    success = asyncio.run(run_downloads(laws, concurrency))
+
+    console.print(f"\n[green]Done![/green] Successfully downloaded: {success}/{len(laws)}")
+
+
+if __name__ == "__main__":
+    download()

scripts/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "vlc-downloader"
+version = "1.0.0"
+description = "Vietnamese Legal Corpus Downloader"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "httpx>=0.27.0",
+    "beautifulsoup4>=4.12.0",
+    "lxml>=5.0.0",
+    "rich>=13.0.0",
+    "click>=8.1.0",
+]
+
+[project.scripts]
+vlc-download = "downloader:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

scripts/upload_hf.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""
+Upload Vietnamese Legal Corpus to Hugging Face Hub
+"""
+
+import re
+from pathlib import Path
+from datetime import datetime
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn
+from datasets import Dataset, DatasetDict, Features, Value
+from huggingface_hub import HfApi, login
+
+console = Console()
+
+DATA_DIR = Path(__file__).parent.parent / "data"
+
+
+def parse_front_matter(content: str) -> dict:
+    """Parse YAML front matter from markdown file."""
+    metadata = {}
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            for line in parts[1].strip().split("\n"):
+                if ":" in line:
+                    key, value = line.split(":", 1)
+                    value = value.strip().strip('"')
+                    metadata[key.strip()] = value
+    return metadata
+
+
+def extract_body(content: str) -> str:
+    """Extract body content after front matter."""
+    if content.startswith("---"):
+        parts = content.split("---", 2)
+        if len(parts) >= 3:
+            return parts[2].strip()
+    return content
+
+
+def load_corpus() -> list[dict]:
+    """Load all law files into a list of records."""
+    records = []
+    files = sorted(DATA_DIR.glob("*.md"))
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TaskProgressColumn(),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Loading files...", total=len(files))
+
+        for f in files:
+            content = f.read_text(encoding="utf-8")
+            metadata = parse_front_matter(content)
+            body = extract_body(content)
+
+            # Check if has real content
+            has_content = len(body) > 200 and "*Nội dung chưa được tải xuống.*" not in body
+
+            record = {
+                "id": f.stem,
+                "filename": f.name,
+                "title": metadata.get("title", ""),
+                "title_en": metadata.get("title_en", ""),
+                "type": metadata.get("type", ""),
+                "year": int(metadata.get("year", 0)) if metadata.get("year", "").isdigit() else 0,
+                "document_number": metadata.get("document_number", ""),
+                "effective_date": metadata.get("effective_date", ""),
+                "status": metadata.get("status", ""),
+                "url": metadata.get("url", ""),
+                "downloaded_at": metadata.get("downloaded_at", ""),
+                "has_content": has_content,
+                "content": body if has_content else "",
+                "content_length": len(body),
+            }
+            records.append(record)
+            progress.advance(task)
+
+    return records
+
+
+def create_dataset(records: list[dict]) -> Dataset:
+    """Create a Hugging Face Dataset from records."""
+    features = Features({
+        "id": Value("string"),
+        "filename": Value("string"),
+        "title": Value("string"),
+        "title_en": Value("string"),
+        "type": Value("string"),
+        "year": Value("int32"),
+        "document_number": Value("string"),
+        "effective_date": Value("string"),
+        "status": Value("string"),
+        "url": Value("string"),
+        "downloaded_at": Value("string"),
+        "has_content": Value("bool"),
+        "content": Value("string"),
+        "content_length": Value("int32"),
+    })
+
+    return Dataset.from_list(records, features=features)
+
+
+@click.group()
+def cli():
+    """Upload VLC corpus to Hugging Face."""
+    pass
+
+
+@cli.command()
+def preview():
+    """Preview the dataset before uploading."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    records = load_corpus()
+    dataset = create_dataset(records)
+
+    console.print("\n[bold blue]Dataset Preview[/bold blue]\n")
+    console.print(dataset)
+    console.print(f"\n[bold]Features:[/bold]")
+    for name, feat in dataset.features.items():
+        console.print(f"  {name}: {feat}")
+
+    # Statistics
+    codes = sum(1 for r in records if r["type"] == "code")
+    laws = sum(1 for r in records if r["type"] == "law")
+    with_content = sum(1 for r in records if r["has_content"])
+    total_chars = sum(r["content_length"] for r in records)
+
+    console.print(f"\n[bold]Statistics:[/bold]")
+    console.print(f"  Total records: {len(records)}")
+    console.print(f"  Codes (Bộ luật): {codes}")
+    console.print(f"  Laws (Luật): {laws}")
+    console.print(f"  With content: {with_content}")
+    console.print(f"  Total characters: {total_chars:,}")
+
+    # Year distribution
+    years = {}
+    for r in records:
+        y = r["year"]
+        years[y] = years.get(y, 0) + 1
+
+    console.print(f"\n[bold]By Year (top 10):[/bold]")
+    for year in sorted(years.keys(), reverse=True)[:10]:
+        console.print(f"  {year}: {years[year]}")
+
+    # Sample records
+    console.print(f"\n[bold]Sample Records:[/bold]")
+    for r in records[:3]:
+        console.print(f"  - {r['title']} ({r['document_number']}, {r['year']})")
+
+
+@cli.command()
+@click.option("--repo-id", default="undertheseanlp/vietnamese-legal-corpus", help="Hugging Face repo ID")
+@click.option("--private", is_flag=True, help="Make the dataset private")
+@click.option("--token", envvar="HF_TOKEN", help="Hugging Face token")
+def upload(repo_id: str, private: bool, token: str):
+    """Upload dataset to Hugging Face Hub."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    # Login
+    if token:
+        login(token=token)
+    else:
+        console.print("[yellow]No token provided. Using cached credentials.[/yellow]")
+
+    # Load and create dataset
+    console.print("[bold]Loading corpus...[/bold]")
+    records = load_corpus()
+    dataset = create_dataset(records)
+
+    console.print(f"\n[bold]Dataset:[/bold] {dataset}")
+
+    # Upload
+    console.print(f"\n[bold]Uploading to {repo_id}...[/bold]")
+
+    dataset.push_to_hub(
+        repo_id,
+        private=private,
+        commit_message=f"Upload Vietnamese Legal Corpus ({len(records)} documents)",
+    )
+
+    console.print(f"\n[green]Done![/green] Dataset uploaded to: https://huggingface.co/datasets/{repo_id}")
+
+
+@cli.command()
+@click.option("--output", "-o", default="vlc_dataset", help="Output directory")
+def save_local(output: str):
+    """Save dataset locally in Arrow format."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    output_path = Path(output)
+
+    console.print("[bold]Loading corpus...[/bold]")
+    records = load_corpus()
+    dataset = create_dataset(records)
+
+    console.print(f"\n[bold]Dataset:[/bold] {dataset}")
+
+    # Save
+    console.print(f"\n[bold]Saving to {output_path}...[/bold]")
+    dataset.save_to_disk(output_path)
+
+    console.print(f"\n[green]Done![/green] Dataset saved to: {output_path}")
+
+
+@cli.command()
+@click.option("--output", "-o", default="vlc_dataset.parquet", help="Output parquet file")
+def save_parquet(output: str):
+    """Save dataset as Parquet file."""
+    if not DATA_DIR.exists():
+        console.print("[red]Data directory not found[/red]")
+        return
+
+    output_path = Path(output)
+
+    console.print("[bold]Loading corpus...[/bold]")
+    records = load_corpus()
+    dataset = create_dataset(records)
+
+    console.print(f"\n[bold]Dataset:[/bold] {dataset}")
+
+    # Save
+    console.print(f"\n[bold]Saving to {output_path}...[/bold]")
+    dataset.to_parquet(output_path)
+
+    console.print(f"\n[green]Done![/green] Dataset saved to: {output_path}")
+    console.print(f"  Size: {output_path.stat().st_size / 1024 / 1024:.2f} MB")
+
+
+if __name__ == "__main__":
+    cli()