Repair VGGFace2 streaming loader

README.md

@@ -3,6 +3,31 @@ license: cc-by-nc-4.0
 paperswithcode_id: vggface2
 pretty_name: vggface2
 ---
+
+## Bounded streaming
+
+`datasets==5.0.0` does not execute this repository's remote Python loader
+through `load_dataset()`. Clone code and metadata without downloading Git LFS
+objects, then use the project-side module directly:
+
+```shell
+GIT_LFS_SKIP_SMUDGE=1 git clone https://huggingface.co/datasets/ProgramComputer/VGGFace2
+```
+
+Archive bytes are read sequentially and are not extracted or cached.
+
+```python
+from VGGFace2 import load_streaming
+
+dataset = load_streaming(
+    split="train",
+    revision="ad5f6b5a5f560621fd7efb9b79c956d27d427a08",
+    cache_dir="./metadata-cache",
+    scratch_dir="./stream-scratch",
+)
+first_hundred = list(dataset.take(100))
+```
+
 ```
 @article{DBLP:journals/corr/abs-1710-08092,
   author       = {Qiong Cao and
@@ -21,4 +46,4 @@ pretty_name: vggface2
   biburl       = {https://dblp.org/rec/journals/corr/abs-1710-08092.bib},
   bibsource    = {dblp computer science bibliography, https://dblp.org}
 }
-```
+```

VGGFace2.py

@@ -1,4 +1,3 @@
-# coding=utf-8
 # Copyright 2022 The HuggingFace Datasets Authors and ProgramComputer.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,174 +12,750 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# Lint as: python3
-"""VGGFace2 audio-visual human speech dataset."""
+from __future__ import annotations
 
-import json
+import csv
+import hashlib
+import io
+import math
 import os
 import re
-from urllib.parse import urlparse, parse_qs
-from getpass import getpass
-from hashlib import sha256
-from itertools import repeat
-from multiprocessing import Manager, Pool, Process
-from pathlib import Path
-from shutil import copyfileobj
-from warnings import catch_warnings, filterwarnings
-from urllib3.exceptions import InsecureRequestWarning
-
-import pandas as pd
-import requests
+import sqlite3
+import tarfile
+import tempfile
+import time
+import warnings
+from pathlib import Path, PurePosixPath
+from typing import Any, Iterable, Mapping
+from urllib.parse import urlsplit
 
 import datasets
+import requests
+from PIL import Image as PILImage
+from PIL import UnidentifiedImageError
 
-_DESCRIPTION = "VGGFace2 is a large-scale face recognition dataset. Images are downloaded from Google Image Search and have large variations in pose, age, illumination, ethnicity and profession."
-_CITATION = """\
-@article{DBLP:journals/corr/abs-1710-08092,
-  author       = {Qiong Cao and
-                  Li Shen and
-                  Weidi Xie and
-                  Omkar M. Parkhi and
-                  Andrew Zisserman},
-  title        = {VGGFace2: {A} dataset for recognising faces across pose and age},
-  journal      = {CoRR},
-  volume       = {abs/1710.08092},
-  year         = {2017},
-  url          = {http://arxiv.org/abs/1710.08092},
-  eprinttype    = {arXiv},
-  eprint       = {1710.08092},
-  timestamp    = {Wed, 04 Aug 2021 07:50:14 +0200},
-  biburl       = {https://dblp.org/rec/journals/corr/abs-1710-08092.bib},
-  bibsource    = {dblp computer science bibliography, https://dblp.org}
-}
-"""
 
+DEFAULT_REPO_ID = "ProgramComputer/VGGFace2"
+DEFAULT_REVISION = "ad5f6b5a5f560621fd7efb9b79c956d27d427a08"
+OXFORD_METADATA_REVISION = "921df0a400f599d0b1a201fbfbb9117e6d794e0d"
 
+DEFAULT_CONNECT_TIMEOUT = 10.0
+DEFAULT_READ_TIMEOUT = 60.0
+DEFAULT_MAX_RETRIES = 3
+DEFAULT_BACKOFF_SECONDS = 0.5
+DEFAULT_MAX_METADATA_BYTES = 16 * 1024 * 1024
+DEFAULT_MAX_METADATA_ENTRIES = 500_000
+DEFAULT_MAX_IMAGE_BYTES = 64 * 1024 * 1024
+DEFAULT_MAX_IMAGE_PIXELS = 4096 * 4096
+DEFAULT_MAX_SCRATCH_BYTES = 512 * 1024 * 1024
 
-_URLS = {
-    "default": {
-        "train": "https://huggingface.co/datasets/ProgramComputer/VGGFace2/resolve/main/data/vggface2_train.tar.gz",
-        "test": "https://huggingface.co/datasets/ProgramComputer/VGGFace2/resolve/main/data/vggface2_test.tar.gz",
-    }
+_ATTRIBUTE_FILES = {
+    "male": "01-Male.txt",
+    "black_hair": "02-Black_Hair.txt",
+    "brown_hair": "03-Brown_Hair.txt",
+    "gray_hair": "04-Gray_Hair.txt",
+    "blond_hair": "05-Blond_Hair.txt",
+    "long_hair": "06-Long_Hair.txt",
+    "mustache_or_beard": "07-Mustache_or_Beard.txt",
+    "wearing_hat": "08-Wearing_Hat.txt",
+    "eyeglasses": "09-Eyeglasses.txt",
+    "sunglasses": "10-Sunglasses.txt",
+    "mouth_open": "11-Mouth_Open.txt",
 }
+_ATTRIBUTE_NAMES = tuple(_ATTRIBUTE_FILES)
+_IMAGE_SUFFIXES = {".bmp", ".jpeg", ".jpg", ".png", ".webp"}
+_CLASS_ID_PATTERN = re.compile(r"n\d{6}")
+_IMAGE_ID_PATTERN = re.compile(r"\d{4}_\d{2}")
+_FILENAME_PATTERN = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]*")
+_RETRYABLE_STATUS_CODES = {408, 429, 500, 502, 503, 504}
+
+FEATURES = datasets.Features(
+    {
+        "image": datasets.Image(decode=False),
+        "image_key": datasets.Value("string"),
+        "filename": datasets.Value("string"),
+        "image_id": datasets.Value("string"),
+        "class_id": datasets.Value("string"),
+        "identity": datasets.Value("string"),
+        "split": datasets.Value("string"),
+        "gender": datasets.Value("string"),
+        "sample_num": datasets.Value("uint64"),
+        "flag": datasets.Value("bool"),
+        "male": datasets.Value("bool"),
+        "black_hair": datasets.Value("bool"),
+        "brown_hair": datasets.Value("bool"),
+        "gray_hair": datasets.Value("bool"),
+        "blond_hair": datasets.Value("bool"),
+        "long_hair": datasets.Value("bool"),
+        "mustache_or_beard": datasets.Value("bool"),
+        "wearing_hat": datasets.Value("bool"),
+        "eyeglasses": datasets.Value("bool"),
+        "sunglasses": datasets.Value("bool"),
+        "mouth_open": datasets.Value("bool"),
+    }
+)
+
+
+def _positive_number(value: float, name: str) -> float:
+    number = float(value)
+    if not math.isfinite(number) or number <= 0:
+        raise ValueError(f"{name} must be finite and positive")
+    return number
+
+
+def _positive_integer(value: int, name: str) -> int:
+    number = int(value)
+    if number <= 0:
+        raise ValueError(f"{name} must be positive")
+    return number
+
+
+def _default_cache_dir() -> Path:
+    hf_home = os.environ.get("HF_HOME")
+    root = Path(hf_home).expanduser() if hf_home else Path.home() / ".cache" / "huggingface"
+    return root / "vggface2-streaming"
+
+
+def _parse_boolean(value: str, source: str) -> bool:
+    normalized = value.strip().lower()
+    if normalized in {"1", "true"}:
+        return True
+    if normalized in {"0", "false"}:
+        return False
+    raise ValueError(f"Expected a boolean value in {source}, got {value!r}")
+
+
+def _parse_image_path(value: str, source: str) -> tuple[str, str, str, str]:
+    if not value or value.startswith(("/", "\\")) or "\\" in value:
+        raise ValueError(f"Malformed image path in {source}: {value!r}")
+    parts = value.split("/")
+    if len(parts) < 2 or any(
+        part in {"", ".", ".."} or _FILENAME_PATTERN.fullmatch(part) is None
+        for part in parts
+    ):
+        raise ValueError(f"Malformed image path in {source}: {value!r}")
+
+    class_id, filename = parts[-2:]
+    if _CLASS_ID_PATTERN.fullmatch(class_id) is None:
+        raise ValueError(
+            f"Malformed image path in {source}: expected nNNNNNN/filename, got {value!r}"
+        )
+    if _FILENAME_PATTERN.fullmatch(filename) is None:
+        raise ValueError(f"Malformed image filename in {source}: {filename!r}")
 
+    suffix = Path(filename).suffix.lower()
+    if suffix not in _IMAGE_SUFFIXES:
+        raise ValueError(f"Unsupported image suffix in {source}: {filename!r}")
+    image_id = filename[: -len(suffix)]
+    if _IMAGE_ID_PATTERN.fullmatch(image_id) is None:
+        raise ValueError(f"Malformed image filename in {source}: {filename!r}")
+    return class_id, filename, image_id, f"{class_id}/{image_id}"
 
 
-class VGGFace2(datasets.GeneratorBasedBuilder):
-    """VGGFace2 is dataset contains faces from Google Search"""
+def _is_image_path(value: str) -> bool:
+    return Path(PurePosixPath(value).name).suffix.lower() in _IMAGE_SUFFIXES
 
-    VERSION = datasets.Version("1.0.0")
 
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig( version=VERSION
+class VGGFace2:
+    """Stream VGGFace2 records without extracting or caching either archive."""
+
+    features = FEATURES
+
+    def __init__(
+        self,
+        *,
+        repo_id: str = DEFAULT_REPO_ID,
+        revision: str = DEFAULT_REVISION,
+        token: str | None = None,
+        cache_dir: str | Path | None = None,
+        scratch_dir: str | Path | None = None,
+        connect_timeout: float = DEFAULT_CONNECT_TIMEOUT,
+        read_timeout: float = DEFAULT_READ_TIMEOUT,
+        max_retries: int = DEFAULT_MAX_RETRIES,
+        backoff_seconds: float = DEFAULT_BACKOFF_SECONDS,
+        max_metadata_bytes: int = DEFAULT_MAX_METADATA_BYTES,
+        max_metadata_entries: int = DEFAULT_MAX_METADATA_ENTRIES,
+        max_image_bytes: int = DEFAULT_MAX_IMAGE_BYTES,
+        max_image_pixels: int = DEFAULT_MAX_IMAGE_PIXELS,
+        max_scratch_bytes: int = DEFAULT_MAX_SCRATCH_BYTES,
+        archive_urls: Mapping[str, str] | None = None,
+        identity_url: str | None = None,
+        attribute_urls: Mapping[str, str] | None = None,
+    ) -> None:
+        if not str(repo_id).strip():
+            raise ValueError("repo_id must not be empty")
+        if re.fullmatch(r"[0-9a-f]{40}", str(revision)) is None:
+            raise ValueError("revision must be a 40-character lowercase commit SHA")
+        if not 0 <= int(max_retries) <= 10:
+            raise ValueError("max_retries must be between 0 and 10")
+        if not math.isfinite(float(backoff_seconds)) or float(backoff_seconds) < 0:
+            raise ValueError("backoff_seconds must be finite and non-negative")
+
+        self.repo_id = str(repo_id)
+        self.revision = str(revision)
+        self.token = token
+        self.cache_dir = Path(cache_dir).expanduser() if cache_dir else _default_cache_dir()
+        self.scratch_dir = (
+            Path(scratch_dir).expanduser() if scratch_dir else Path(tempfile.gettempdir())
+        )
+        self.connect_timeout = _positive_number(connect_timeout, "connect_timeout")
+        self.read_timeout = _positive_number(read_timeout, "read_timeout")
+        self.max_retries = int(max_retries)
+        self.backoff_seconds = float(backoff_seconds)
+        self.max_metadata_bytes = _positive_integer(
+            max_metadata_bytes, "max_metadata_bytes"
+        )
+        self.max_metadata_entries = _positive_integer(
+            max_metadata_entries, "max_metadata_entries"
         )
-    ]
-
-    def _info(self):
-        features = {
-            "image": datasets.Image(),
-            "image_id": datasets.Value("string"),
-            "class_id": datasets.Value("string"),
-            "identity": datasets.Value("string"),
-            'gender': datasets.Value("string"),
-            'sample_num':datasets.Value("uint64"), 
-            'flag':datasets.Value("bool"),
-            "male": datasets.Value("bool"),
-            "black_hair": datasets.Value("bool"),
-            "gray_hair": datasets.Value("bool"),
-            "blond_hair": datasets.Value("bool"),
-            "long_hair": datasets.Value("bool"),
-            "mustache_or_beard": datasets.Value("bool"),
-            "wearing_hat": datasets.Value("bool"),
-            "eyeglasses": datasets.Value("bool"),
-            "sunglasses": datasets.Value("bool"),
-            "mouth_open": datasets.Value("bool"),
+        self.max_image_bytes = _positive_integer(max_image_bytes, "max_image_bytes")
+        self.max_image_pixels = _positive_integer(max_image_pixels, "max_image_pixels")
+        self.max_scratch_bytes = _positive_integer(
+            max_scratch_bytes, "max_scratch_bytes"
+        )
+
+        default_archives = {
+            split: (
+                f"https://huggingface.co/datasets/{self.repo_id}/resolve/"
+                f"{self.revision}/data/vggface2_{split}.tar.gz"
+            )
+            for split in ("train", "test")
         }
+        self.archive_urls = dict(archive_urls or default_archives)
+        if set(self.archive_urls) != {"train", "test"}:
+            raise ValueError("archive_urls must contain exactly train and test")
 
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            supervised_keys=datasets.info.SupervisedKeysData("file", "class_id"),
-            features=datasets.Features(features),
-            citation=_CITATION,
+        self.identity_url = identity_url or (
+            f"https://huggingface.co/datasets/{self.repo_id}/resolve/"
+            f"{self.revision}/meta/identity_meta.csv"
         )
+        default_attributes = {
+            name: (
+                "https://raw.githubusercontent.com/ox-vgg/vgg_face2/"
+                f"{OXFORD_METADATA_REVISION}/attributes/{filename}"
+            )
+            for name, filename in _ATTRIBUTE_FILES.items()
+        }
+        self.attribute_urls = dict(attribute_urls or default_attributes)
+        if set(self.attribute_urls) != set(_ATTRIBUTE_NAMES):
+            raise ValueError("attribute_urls must contain all eleven Oxford attributes")
 
-    def _split_generators(self, dl_manager):
-        targets = (
-            ["01-Male.txt", "02-Black_Hair.txt","03-Brown_Hair.txt","04-Gray_Hair.txt","05-Blond_Hair.txt","06-Long_Hair.txt","07-Mustache_or_Beard.txt","08-Wearing_Hat.txt","09-Eyeglasses.txt","10-Sunglasses.txt","11-Mouth_Open.txt"]
+    def _session(self) -> requests.Session:
+        session = requests.Session()
+        session.headers.update(
+            {
+                "Accept-Encoding": "identity",
+                "User-Agent": "ProgramComputer-VGGFace2-bounded-streaming/2",
+            }
         )
-        target_dict =   dict(
-                (
-                    re.sub(r"^\d+-|\.txt$","",target),
-                    f"https://raw.githubusercontent.com/ox-vgg/vgg_face2/master/attributes/{target}",
+        return session
+
+    def _open_response(
+        self,
+        session: requests.Session,
+        url: str,
+    ) -> requests.Response:
+        attempts = self.max_retries + 1
+        last_error: Exception | None = None
+        for attempt in range(attempts):
+            response: requests.Response | None = None
+            try:
+                hostname = (urlsplit(url).hostname or "").lower()
+                headers = None
+                if self.token and (
+                    hostname == "huggingface.co" or hostname.endswith(".huggingface.co")
+                ):
+                    headers = {"Authorization": f"Bearer {self.token}"}
+                response = session.get(
+                    url,
+                    headers=headers,
+                    stream=True,
+                    timeout=(self.connect_timeout, self.read_timeout),
                 )
-                for target in targets
-            )
-        target_dict['identity'] = "https://huggingface.co/datasets/ProgramComputer/VGGFace2/raw/main/meta/identity_meta.csv"
-        metadata = dl_manager.download(
-            target_dict
+                if response.status_code in _RETRYABLE_STATUS_CODES:
+                    response.close()
+                    raise requests.HTTPError(
+                        f"HTTP {response.status_code}", response=response
+                    )
+                response.raise_for_status()
+                return response
+            except requests.RequestException as exc:
+                last_error = exc
+                if response is not None:
+                    response.close()
+                if attempt + 1 >= attempts:
+                    break
+                delay = min(30.0, self.backoff_seconds * (2**attempt))
+                if delay:
+                    time.sleep(delay)
+        raise RuntimeError(f"Unable to open {url} after {attempts} attempts") from last_error
+
+    def _metadata_cache_path(self, label: str, url: str) -> Path:
+        digest = hashlib.sha256(url.encode("utf-8")).hexdigest()[:20]
+        suffix = Path(PurePosixPath(url.split("?", 1)[0]).name).suffix or ".metadata"
+        return self.cache_dir / f"{label}-{digest}{suffix}"
+
+    def _cached_metadata(
+        self,
+        session: requests.Session,
+        label: str,
+        url: str,
+        remaining_bytes: int,
+    ) -> Path:
+        target = self._metadata_cache_path(label, url)
+        if target.is_file():
+            size = target.stat().st_size
+            if size <= 0:
+                raise ValueError(f"Cached metadata file is empty: {target}")
+            if size > remaining_bytes:
+                raise ValueError(
+                    f"Metadata exceeds max_metadata_bytes while reading {label}: {size} bytes"
+                )
+            return target
+
+        self.cache_dir.mkdir(parents=True, exist_ok=True)
+        response = self._open_response(session, url)
+        content_length = response.headers.get("Content-Length")
+        if content_length is not None:
+            try:
+                announced_size = int(content_length)
+            except ValueError as exc:
+                response.close()
+                raise ValueError(f"Invalid Content-Length for {label}: {content_length!r}") from exc
+            if announced_size > remaining_bytes:
+                response.close()
+                raise ValueError(
+                    f"Metadata exceeds max_metadata_bytes while reading {label}: "
+                    f"{announced_size} bytes"
+                )
+
+        handle = tempfile.NamedTemporaryFile(
+            mode="wb",
+            prefix=f"{target.name}.",
+            suffix=".partial",
+            dir=self.cache_dir,
+            delete=False,
         )
+        partial = Path(handle.name)
+        total = 0
+        try:
+            with handle, response:
+                for chunk in response.iter_content(chunk_size=64 * 1024):
+                    if not chunk:
+                        continue
+                    total += len(chunk)
+                    if total > remaining_bytes:
+                        raise ValueError(
+                            f"Metadata exceeds max_metadata_bytes while reading {label}: "
+                            f"more than {remaining_bytes} bytes"
+                        )
+                    handle.write(chunk)
+                handle.flush()
+                os.fsync(handle.fileno())
+            if total <= 0:
+                raise ValueError(f"Downloaded metadata file is empty: {label}")
+            os.replace(partial, target)
+        except Exception:
+            partial.unlink(missing_ok=True)
+            raise
+        return target
 
-        mapped_paths_train = dl_manager.iter_archive( 
-                        _URLS["default"]["train"]
+    def _metadata_paths(self, session: requests.Session) -> dict[str, Path]:
+        sources = [("identity", self.identity_url), *self.attribute_urls.items()]
+        paths: dict[str, Path] = {}
+        used_bytes = 0
+        for label, url in sources:
+            path = self._cached_metadata(
+                session,
+                label,
+                url,
+                remaining_bytes=self.max_metadata_bytes - used_bytes,
+            )
+            used_bytes += path.stat().st_size
+            if used_bytes > self.max_metadata_bytes:
+                raise ValueError(
+                    f"Metadata exceeds max_metadata_bytes: {used_bytes} bytes"
+                )
+            paths[label] = path
+        return paths
+
+    def _connect_registry(self, database_path: Path) -> sqlite3.Connection:
+        connection = sqlite3.connect(database_path)
+        connection.execute("PRAGMA journal_mode = OFF")
+        connection.execute("PRAGMA synchronous = OFF")
+        connection.execute("PRAGMA temp_store = MEMORY")
+        connection.execute("PRAGMA cache_size = -4096")
+        page_size = int(connection.execute("PRAGMA page_size").fetchone()[0])
+        max_pages = max(1, self.max_scratch_bytes // page_size)
+        connection.execute(f"PRAGMA max_page_count = {max_pages}")
+        connection.execute(
+            """
+            CREATE TABLE identities (
+                class_id TEXT PRIMARY KEY,
+                identity TEXT NOT NULL,
+                sample_num TEXT NOT NULL,
+                flag INTEGER NOT NULL,
+                gender TEXT NOT NULL
+            ) WITHOUT ROWID
+            """
+        )
+        attribute_columns = ", ".join(f"{name} INTEGER" for name in _ATTRIBUTE_NAMES)
+        connection.execute(
+            f"CREATE TABLE attributes (image_key TEXT PRIMARY KEY, {attribute_columns}) "
+            "WITHOUT ROWID"
+        )
+        connection.execute(
+            "CREATE TABLE seen_images (image_key TEXT PRIMARY KEY) WITHOUT ROWID"
         )
-        mapped_paths_test = dl_manager.iter_archive( 
-                        _URLS["default"]["test"]
+        return connection
+
+    def _check_scratch(self, database_path: Path) -> None:
+        size = database_path.stat().st_size if database_path.exists() else 0
+        if size > self.max_scratch_bytes:
+            raise RuntimeError(
+                f"Scratch usage exceeds max_scratch_bytes: {size} > {self.max_scratch_bytes}"
+            )
+
+    def _load_identity_metadata(
+        self,
+        connection: sqlite3.Connection,
+        path: Path,
+        entry_count: int,
+    ) -> int:
+        with path.open("r", encoding="utf-8-sig", newline="") as handle:
+            reader = csv.reader(handle, skipinitialspace=True)
+            try:
+                header = [value.strip() for value in next(reader)]
+            except StopIteration as exc:
+                raise ValueError(f"Identity metadata is empty: {path}") from exc
+            expected = ["Class_ID", "Name", "Sample_Num", "Flag", "Gender"]
+            if header != expected:
+                raise ValueError(f"Unexpected identity metadata header in {path}: {header}")
+
+            for line_number, row in enumerate(reader, start=2):
+                if not row or all(not value.strip() for value in row):
+                    continue
+                entry_count += 1
+                if entry_count > self.max_metadata_entries:
+                    raise ValueError(
+                        f"Metadata exceeds max_metadata_entries: {entry_count}"
+                    )
+                if len(row) != 5:
+                    raise ValueError(
+                        f"Malformed identity metadata row {line_number} in {path}: {row!r}"
+                    )
+                class_id, identity, sample_value, flag_value, gender = (
+                    value.strip() for value in row
+                )
+                if _CLASS_ID_PATTERN.fullmatch(class_id) is None:
+                    raise ValueError(
+                        f"Malformed class ID at row {line_number} in {path}: {class_id!r}"
+                    )
+                if not identity:
+                    raise ValueError(f"Identity is empty at row {line_number} in {path}")
+                try:
+                    sample_num = int(sample_value)
+                except ValueError as exc:
+                    raise ValueError(
+                        f"Invalid sample count at row {line_number} in {path}: {sample_value!r}"
+                    ) from exc
+                if not 0 <= sample_num < 2**64:
+                    raise ValueError(
+                        f"Invalid sample count at row {line_number} in {path}: {sample_value!r}"
+                    )
+                flag = _parse_boolean(flag_value, f"row {line_number} of {path}")
+                gender = gender.lower()
+                if gender not in {"f", "m"}:
+                    raise ValueError(
+                        f"Invalid gender at row {line_number} in {path}: {gender!r}"
+                    )
+                try:
+                    connection.execute(
+                        "INSERT INTO identities VALUES (?, ?, ?, ?, ?)",
+                        (class_id, identity, str(sample_num), int(flag), gender),
+                    )
+                except sqlite3.IntegrityError as exc:
+                    raise ValueError(f"Duplicate identity metadata key: {class_id}") from exc
+        connection.commit()
+        return entry_count
+
+    def _load_attribute_metadata(
+        self,
+        connection: sqlite3.Connection,
+        name: str,
+        path: Path,
+        entry_count: int,
+    ) -> int:
+        with path.open("r", encoding="utf-8-sig", newline="") as handle:
+            for line_number, line in enumerate(handle, start=1):
+                value = line.strip()
+                if not value:
+                    continue
+                entry_count += 1
+                if entry_count > self.max_metadata_entries:
+                    raise ValueError(
+                        f"Metadata exceeds max_metadata_entries: {entry_count}"
+                    )
+                parts = value.split("\t")
+                if len(parts) != 2:
+                    raise ValueError(
+                        f"Malformed {name} row {line_number} in {path}: {value!r}"
+                    )
+                image_path, attribute_value = (part.strip() for part in parts)
+                _, _, _, image_key = _parse_image_path(
+                    image_path, f"row {line_number} of {path}"
+                )
+                parsed_value = int(
+                    _parse_boolean(attribute_value, f"row {line_number} of {path}")
+                )
+                existing = connection.execute(
+                    f"SELECT {name} FROM attributes WHERE image_key = ?", (image_key,)
+                ).fetchone()
+                if existing is not None and existing[0] is not None:
+                    raise ValueError(f"Duplicate {name} metadata key: {image_key}")
+                if existing is None:
+                    connection.execute(
+                        f"INSERT INTO attributes (image_key, {name}) VALUES (?, ?)",
+                        (image_key, parsed_value),
+                    )
+                else:
+                    connection.execute(
+                        f"UPDATE attributes SET {name} = ? WHERE image_key = ?",
+                        (parsed_value, image_key),
+                    )
+        connection.commit()
+        return entry_count
+
+    def _build_metadata_registry(
+        self,
+        connection: sqlite3.Connection,
+        metadata_paths: Mapping[str, Path],
+        database_path: Path,
+    ) -> None:
+        entry_count = self._load_identity_metadata(
+            connection, metadata_paths["identity"], entry_count=0
         )
-        return [
-            datasets.SplitGenerator(
-                name="train",
-                gen_kwargs={
-                    "paths": mapped_paths_train,
-                    "meta_paths": metadata,
-                },
-            ),
-            datasets.SplitGenerator(
-                name="test",
-                gen_kwargs={
-                    "paths": mapped_paths_test,
-                    "meta_paths": metadata,
-                },
-            ),
-        ]
-
-    def _generate_examples(self, paths, meta_paths):
-        key = 0
-        meta = pd.read_csv(
-                meta_paths["identity"],
-                sep=", "
+        self._check_scratch(database_path)
+        for name in _ATTRIBUTE_NAMES:
+            entry_count = self._load_attribute_metadata(
+                connection,
+                name,
+                metadata_paths[name],
+                entry_count=entry_count,
             )
-        for key,conf in [(k,v) for (k,v) in meta_paths.items() if k != "identity"]:
-            
-            temp = pd.read_csv(conf,sep='\t', header=None)
-            temp.columns = ['Image_Path', key]
-            
-            temp['Class_ID'] = temp['Image_Path'].str.split('/').str[0]
-            #temp['Image_Name'] = temp['Image_Path'].str.split('/').str[1]
-            
-            temp.drop(columns=['Image_Path'], inplace=True)
-            
-            meta = meta.merge(temp, on='Class_ID', how='left')
-        for file_path, file_obj in paths:
-
-                label = file_path.split("/")[2]
-                yield file_path, {
-                        "image": {"path": file_path, "bytes": file_obj.read()},
-            # "image_id": datasets.Value("string"),
-            # "class_id": datasets.Value("string"),
-            # "identity": datasets.Value("string"),
-            # 'gender': dataset.Value("string"),
-            # 'sample_num':dataset.Value("uint64"), 
-            # 'flag':dataset.Value("bool"),
-            # "male": datasets.Value("bool"),
-            # "black_hair": datasets.Value("bool"),
-            # "gray_hair": datasets.Value("bool"),
-            # "blond_hair": datasets.Value("bool"),
-            # "long_hair": datasets.Value("bool"),
-            # "mustache_or_beard": datasets.Value("bool"),
-            # "wearing_hat": datasets.Value("bool"),
-            # "eyeglasses": datasets.Value("bool"),
-            # "sunglasses": datasets.Value("bool"),
-            #"mouth_open": datasets.Value("bool")
-                    }
-                key+= 1
-                        
+            self._check_scratch(database_path)
+
+    def _read_image(self, member: tarfile.TarInfo, archive: tarfile.TarFile) -> bytes:
+        if member.size <= 0:
+            raise ValueError(f"Image is empty in archive: {member.name}")
+        if member.size > self.max_image_bytes:
+            raise ValueError(
+                f"Image exceeds max_image_bytes in archive: {member.name} "
+                f"({member.size} > {self.max_image_bytes})"
+            )
+        extracted = archive.extractfile(member)
+        if extracted is None:
+            raise ValueError(f"Unable to read image from archive: {member.name}")
+        try:
+            data = extracted.read(self.max_image_bytes + 1)
+        finally:
+            extracted.close()
+        if len(data) != member.size:
+            raise ValueError(
+                f"Truncated image in archive: {member.name} "
+                f"({len(data)} of {member.size} bytes)"
+            )
+        if len(data) > self.max_image_bytes:
+            raise ValueError(f"Image exceeds max_image_bytes in archive: {member.name}")
+
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("error", PILImage.DecompressionBombWarning)
+                with PILImage.open(io.BytesIO(data)) as image:
+                    width, height = image.size
+                    if width <= 0 or height <= 0 or width * height > self.max_image_pixels:
+                        raise ValueError(
+                            f"Image dimensions exceed max_image_pixels in archive: "
+                            f"{member.name} ({width}x{height})"
+                        )
+                    image.verify()
+        except ValueError:
+            raise
+        except (
+            OSError,
+            UnidentifiedImageError,
+            PILImage.DecompressionBombError,
+            PILImage.DecompressionBombWarning,
+        ) as exc:
+            raise ValueError(f"Corrupt image in archive: {member.name}") from exc
+        return data
+
+    def _record(
+        self,
+        connection: sqlite3.Connection,
+        split: str,
+        class_id: str,
+        filename: str,
+        image_id: str,
+        image_key: str,
+        image_bytes: bytes,
+    ) -> dict[str, Any]:
+        identity = connection.execute(
+            "SELECT identity, sample_num, flag, gender FROM identities WHERE class_id = ?",
+            (class_id,),
+        ).fetchone()
+        if identity is None:
+            raise ValueError(f"Identity metadata is missing for image key: {image_key}")
+        attributes = connection.execute(
+            f"SELECT {', '.join(_ATTRIBUTE_NAMES)} FROM attributes WHERE image_key = ?",
+            (image_key,),
+        ).fetchone()
+        attribute_values = attributes or (None,) * len(_ATTRIBUTE_NAMES)
+
+        record: dict[str, Any] = {
+            "image": {"path": f"{class_id}/{filename}", "bytes": image_bytes},
+            "image_key": image_key,
+            "filename": filename,
+            "image_id": image_id,
+            "class_id": class_id,
+            "identity": str(identity[0]),
+            "split": split,
+            "gender": str(identity[3]),
+            "sample_num": int(identity[1]),
+            "flag": bool(identity[2]),
+        }
+        record.update(
+            {
+                name: None if value is None else bool(value)
+                for name, value in zip(_ATTRIBUTE_NAMES, attribute_values)
+            }
+        )
+        return record
+
+    def _iter_archive(
+        self,
+        session: requests.Session,
+        split: str,
+        connection: sqlite3.Connection,
+        database_path: Path,
+    ) -> Iterable[dict[str, Any]]:
+        response = self._open_response(session, self.archive_urls[split])
+        archive: tarfile.TarFile | None = None
+        yielded = 0
+        try:
+            response.raw.decode_content = False
+            archive = tarfile.open(fileobj=response.raw, mode="r|gz")
+            for member in archive:
+                if member.name.startswith(("/", "\\")) or "\\" in member.name:
+                    raise ValueError(f"Malformed archive member path: {member.name!r}")
+                checked_name = (
+                    member.name[:-1]
+                    if member.isdir() and member.name.endswith("/")
+                    else member.name
+                )
+                path_parts = checked_name.split("/")
+                if any(part in {"", ".", ".."} for part in path_parts):
+                    raise ValueError(f"Malformed archive member path: {member.name!r}")
+                if member.isdir():
+                    continue
+                if not member.isfile():
+                    raise ValueError(f"Unsupported archive member type: {member.name!r}")
+                if not _is_image_path(member.name):
+                    continue
+
+                class_id, filename, image_id, image_key = _parse_image_path(
+                    member.name, "VGGFace2 archive"
+                )
+                try:
+                    connection.execute(
+                        "INSERT INTO seen_images VALUES (?)", (image_key,)
+                    )
+                except sqlite3.IntegrityError as exc:
+                    raise ValueError(f"Duplicate canonical image key: {image_key}") from exc
+                except sqlite3.OperationalError as exc:
+                    if "full" not in str(exc).lower():
+                        raise
+                    raise RuntimeError(
+                        "Scratch registry reached max_scratch_bytes"
+                    ) from exc
+                if yielded % 1024 == 0:
+                    try:
+                        connection.commit()
+                    except sqlite3.OperationalError as exc:
+                        raise RuntimeError(
+                            "Scratch registry reached max_scratch_bytes"
+                        ) from exc
+                    self._check_scratch(database_path)
+
+                image_bytes = self._read_image(member, archive)
+                yield self._record(
+                    connection,
+                    split,
+                    class_id,
+                    filename,
+                    image_id,
+                    image_key,
+                    image_bytes,
+                )
+                yielded += 1
+            try:
+                connection.commit()
+            except sqlite3.OperationalError as exc:
+                raise RuntimeError("Scratch registry reached max_scratch_bytes") from exc
+            self._check_scratch(database_path)
+        except tarfile.TarError as exc:
+            raise RuntimeError(f"Unable to stream {split} tar archive") from exc
+        finally:
+            if archive is not None:
+                archive.close()
+            response.close()
+
+    def iter_split(self, split: str) -> Iterable[dict[str, Any]]:
+        """Iterate one pinned source archive in its original member order."""
+        normalized_split = str(split)
+        if normalized_split not in {"train", "test"}:
+            raise ValueError("split must be train or test")
+
+        self.scratch_dir.mkdir(parents=True, exist_ok=True)
+        with tempfile.TemporaryDirectory(
+            prefix="vggface2-stream-", dir=self.scratch_dir
+        ) as temporary:
+            database_path = Path(temporary) / "registry.sqlite3"
+            connection: sqlite3.Connection | None = None
+            with self._session() as session:
+                try:
+                    metadata_paths = self._metadata_paths(session)
+                    connection = self._connect_registry(database_path)
+                    self._build_metadata_registry(
+                        connection, metadata_paths, database_path
+                    )
+                    yield from self._iter_archive(
+                        session,
+                        normalized_split,
+                        connection,
+                        database_path,
+                    )
+                finally:
+                    if connection is not None:
+                        connection.close()
+
+    def as_dataset(self, split: str) -> datasets.IterableDataset:
+        """Return the supported Hugging Face streaming entry point."""
+        normalized_split = str(split)
+        if normalized_split not in {"train", "test"}:
+            raise ValueError("split must be train or test")
+        return datasets.IterableDataset.from_generator(
+            _iter_loader,
+            features=self.features,
+            gen_kwargs={"loader": self, "split": normalized_split},
+            split=normalized_split,
+        )
+
+
+def _iter_loader(loader: VGGFace2, split: str) -> Iterable[dict[str, Any]]:
+    yield from loader.iter_split(split)
+
+
+def load_streaming(split: str, **loader_kwargs: Any) -> datasets.IterableDataset:
+    """Load a bounded project-side stream from the pinned VGGFace2 revision."""
+    return VGGFace2(**loader_kwargs).as_dataset(split)