dataset: add README, LICENSE, and scripts for uploading

.gitignore

@@ -0,0 +1,16 @@
+# Raw image crawl and the shards built from it: uploaded over HTTP by
+# scripts/upload_to_hub.py, never committed through git.
+glami_images.tar.gz
+images/
+
+# upload_large_folder resume state
+.cache/
+
+# macOS
+.DS_Store
+
+# local venv for the build/upload scripts
+.venv/
+
+# python
+__pycache__/

LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 GLAMI
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -0,0 +1,127 @@
+---
+license: apache-2.0
+task_categories:
+  - image-classification
+  - zero-shot-image-classification
+language:
+  - bg
+  - cs
+  - el
+  - hr
+  - hu
+  - pl
+  - ro
+  - sk
+tags:
+  - e-commerce
+  - duplicate-detection
+  - entity-resolution
+  - multimodal
+size_categories:
+  - 1M<n<10M
+configs:
+  - config_name: images
+    default: true
+    data_files:
+      - split: train
+        path: images/shard-*.parquet
+  - config_name: items
+    data_files:
+      - split: train
+        path: items_train.csv
+      - split: test
+        path: items_test.csv
+  - config_name: splits
+    data_files:
+      - split: train
+        path: train_split.csv
+      - split: validation
+        path: val_split.csv
+  - config_name: groups
+    data_files:
+      - split: g5
+        path: groups_5.csv
+      - split: g6
+        path: groups_6.csv
+      - split: g7
+        path: groups_7.csv
+      - split: g8
+        path: groups_8.csv
+      - split: g9
+        path: groups_9.csv
+      - split: g10
+        path: groups_10.csv
+      - split: hard_5
+        path: groups_hard_5.csv
+      - split: category_5
+        path: groups_category_5.csv
+---
+
+# GLAMI Duplication Detection
+
+Product-duplicate detection over GLAMI e-commerce listings: ~1.3M product
+images plus multilingual titles, descriptions and attributes, with labelled
+groups of items that do or do not refer to the same physical product.
+
+Released under the Apache License 2.0 — see [LICENSE](LICENSE).
+
+> TODO: describe how the labels were produced.
+
+## Structure
+
+| Config | Files | Contents |
+| --- | --- | --- |
+| `images` | `images/shard-*.parquet` | `itemId` → image bytes, one row per product image |
+| `items` | `items_train.csv`, `items_test.csv` | `itemId`, `price`, `colorTagIdsString`, `departmentIds`, `brandEditionTagId`, `title`, `description`, `geo`, and `label` on train |
+| `splits` | `train_split.csv`, `val_split.csv` | train/validation partition of the training items |
+| `groups` | `groups_*.csv` | `item1..itemN`, `label` — candidate groups of 5–10 items, plus `hard_` and `category_` adversarial variants |
+
+Images are keyed by `itemId` alone and are not pre-split. Every other file
+references `itemId`, so all of them join against the same image table and no
+picture is stored twice.
+
+## Usage
+
+```python
+from datasets import load_dataset
+
+images = load_dataset("zidcenek/GLAMIDuplicationDetection", "images", split="train")
+items  = load_dataset("zidcenek/GLAMIDuplicationDetection", "items",  split="train")
+groups = load_dataset("zidcenek/GLAMIDuplicationDetection", "groups", split="g5")
+
+images[0]["image"]    # PIL.Image, decoded lazily
+images[0]["itemId"]
+```
+
+The image config is ~TODO GB, so stream it if you do not want a full local copy:
+
+```python
+images = load_dataset(
+    "zidcenek/GLAMIDuplicationDetection", "images", split="train", streaming=True
+)
+```
+
+To attach images to items, build the `itemId` → row-index map once and index into it:
+
+```python
+index = {item_id: i for i, item_id in enumerate(images["itemId"])}
+row = images[index[items[0]["itemId"]]]
+```
+
+## Reproducing the image shards
+
+```bash
+pip install -U datasets Pillow "huggingface_hub[hf_xet]"
+
+python scripts/build_image_shards.py --inspect    # check the filename -> itemId mapping
+python scripts/build_image_shards.py              # glami_images.tar.gz -> images/shard-*.parquet
+hf auth login
+python scripts/upload_to_hub.py                   # push to the Hub over HTTP
+```
+
+Both scripts are resumable: rerun the same command after an interruption.
+See the header of each for the full options.
+
+## Citation
+
+> TODO

scripts/build_image_shards.py

@@ -0,0 +1,321 @@
+#!/usr/bin/env python3
+"""Pack GLAMI product images into Hub-ready Parquet shards.
+
+Reads images straight out of glami_images.tar.gz in a single streaming pass --
+the 1.3M files are never unpacked onto disk -- and writes
+
+    images/shard-00000.parquet, images/shard-00001.parquet, ...
+
+with the `datasets` Image() feature, so the Hub's Dataset Viewer renders them
+and `load_dataset(..., streaming=True)` works without a loading script.
+
+Images are keyed by itemId only. They are deliberately NOT split into
+train/test: the splits live in items_train.csv / items_test.csv / *_split.csv,
+which reference itemId, so a single image table stays joinable by all of them
+and never stores the same picture twice.
+
+Usage:
+    python scripts/build_image_shards.py --inspect         # peek inside the tarball first
+    python scripts/build_image_shards.py --limit 5000      # small trial run
+    python scripts/build_image_shards.py                   # build locally (resumable)
+    python scripts/build_image_shards.py \
+        --upload-repo zidcenek/GLAMIDuplicationDetection   # build AND upload in one pass
+
+With --upload-repo each batch of shards is pushed and then deleted locally, so
+packing 1.3M images needs a couple of GB of free disk rather than ~16GB.
+
+Requires: pip install datasets Pillow   (Pillow is needed to encode the Image feature)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import re
+import sys
+import tarfile
+import time
+from array import array
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+
+IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp"}
+
+# Magic bytes, checked on every image. Truncated downloads and HTML error
+# pages that got saved with a .jpg name are common in a 1.3M-file crawl and
+# would otherwise poison the shard at load time.
+MAGIC = (
+    (b"\xff\xd8\xff", "jpeg"),
+    (b"\x89PNG\r\n\x1a\n", "png"),
+    (b"GIF87a", "gif"),
+    (b"GIF89a", "gif"),
+    (b"BM", "bmp"),
+)
+
+
+def sniff(data: bytes) -> str | None:
+    for prefix, kind in MAGIC:
+        if data.startswith(prefix):
+            return kind
+    if data[:4] == b"RIFF" and data[8:12] == b"WEBP":
+        return "webp"
+    return None
+
+
+def human(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f}{unit}"
+        n /= 1024
+    return f"{n:.1f}PB"
+
+
+def iter_members(source: Path):
+    """Yield (name, bytes) for every regular file in a tarball or directory."""
+    if source.is_dir():
+        for path in sorted(source.rglob("*")):
+            if path.is_file():
+                yield str(path.relative_to(source)), path.read_bytes()
+        return
+
+    # "r|gz" is the streaming mode: sequential, no seeking, constant memory.
+    with tarfile.open(source, "r|gz") as tar:
+        for member in tar:
+            if not member.isfile():
+                continue
+            handle = tar.extractfile(member)
+            if handle is None:
+                continue
+            yield member.name, handle.read()
+
+
+def make_id_extractor(pattern: str | None):
+    """itemId from a filename. Default: the whole stem if numeric, else its last digit run."""
+    if pattern:
+        rx = re.compile(pattern)
+
+        def extract(stem: str):
+            m = rx.search(stem)
+            return int(m.group(1)) if m else None
+
+        return extract
+
+    trailing = re.compile(r"(\d+)(?!.*\d)")
+
+    def extract(stem: str):
+        if stem.isdigit():
+            return int(stem)
+        m = trailing.search(stem)
+        return int(m.group(1)) if m else None
+
+    return extract
+
+
+def inspect(source: Path, extract, count: int) -> None:
+    print(f"First {count} entries in {source.name}:\n")
+    seen = 0
+    for name, data in iter_members(source):
+        if Path(name).name.startswith("._") or name.startswith("__MACOSX/"):
+            continue
+        stem = Path(name).stem
+        print(
+            f"  {name}\n"
+            f"      itemId={extract(stem)}  format={sniff(data)}  size={human(len(data))}"
+        )
+        seen += 1
+        if seen >= count:
+            break
+    print(
+        "\nCheck that itemId matches the itemId column in items_train.csv."
+        "\nIf it does not, pass --id-regex with a capture group, e.g."
+        '\n  --id-regex "item_(\\d+)_thumb"'
+    )
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--source", type=Path, default=REPO_ROOT / "glami_images.tar.gz",
+                   help="tarball or already-extracted directory of images")
+    p.add_argument("--out", type=Path, default=REPO_ROOT / "images",
+                   help="output directory for the parquet shards")
+    p.add_argument("--shard-mb", type=int, default=400,
+                   help="target uncompressed image bytes per shard (default: 400)")
+    p.add_argument("--id-regex", default=None,
+                   help="regex with one capture group extracting itemId from the filename stem")
+    p.add_argument("--limit", type=int, default=None, help="stop after N images (trial run)")
+    p.add_argument("--inspect", nargs="?", type=int, const=15, default=None,
+                   help="list the first N tar entries and exit, without writing anything")
+    p.add_argument("--allow-duplicates", action="store_true",
+                   help="keep repeated itemIds instead of skipping them")
+    p.add_argument("--upload-repo", default=None, metavar="REPO_ID",
+                   help="upload shards to this Hub dataset as they are built, then delete them "
+                        "locally (e.g. zidcenek/GLAMIDuplicationDetection). Keeps peak disk at "
+                        "--upload-every-mb instead of the full dataset size.")
+    p.add_argument("--upload-every-mb", type=int, default=2000,
+                   help="upload once this many MB of shards have accumulated (default: 2000)")
+    args = p.parse_args()
+
+    if not args.source.exists():
+        sys.exit(f"source not found: {args.source}")
+    if args.source.is_file() and args.source.stat().st_size == 0:
+        sys.exit(f"{args.source} is empty -- is the download still running?")
+
+    extract = make_id_extractor(args.id_regex)
+
+    if args.inspect is not None:
+        inspect(args.source, extract, args.inspect)
+        return 0
+
+    from datasets import Dataset, Features, Image, Value  # imported late so --inspect needs no deps
+    from datasets.utils.logging import disable_progress_bar
+
+    api = None
+    if args.upload_repo:
+        from huggingface_hub import HfApi
+        from huggingface_hub.utils import HfHubHTTPError
+
+        api = HfApi()
+        try:
+            print(f"Uploading to {args.upload_repo} as {api.whoami()['name']}.")
+        except Exception:
+            sys.exit("not authenticated -- run 'hf auth login' (or export HF_TOKEN) first")
+
+    disable_progress_bar()  # one bar per shard is noise across thousands of shards
+    features = Features({"itemId": Value("int64"), "image": Image()})
+    args.out.mkdir(parents=True, exist_ok=True)
+    state_path = args.out / ".build_state.json"
+
+    # Resume support. The gzip stream cannot be seeked, so resuming still has to
+    # decompress its way back to where it stopped -- but it does not re-encode
+    # or re-upload any shard that already exists.
+    state = json.loads(state_path.read_text()) if state_path.exists() else {}
+    shard_no = state.get("next_shard", 0)
+    resume_from = state.get("images_done", 0)
+    skip = resume_from
+    # Every packed itemId is appended here as a flat int64 array. Duplicate
+    # detection therefore survives both a resume and the shards being deleted
+    # after they are uploaded, which is how build_and_upload.py keeps peak disk
+    # down to one wave.
+    seen_path = args.out / ".seen_ids.bin"
+    seen_ids: set[int] = set()
+    if resume_from:
+        print(f"Resuming: {resume_from:,} images already packed into {shard_no} shard(s).")
+        if not args.allow_duplicates and seen_path.exists():
+            packed = array("q")
+            packed.frombytes(seen_path.read_bytes())
+            seen_ids.update(packed)
+            print(f"           {len(seen_ids):,} itemIds loaded back for duplicate checking.")
+
+    pending: list[Path] = []
+    ids: list[int] = []
+    blobs: list[dict] = []
+    pending_bytes = 0
+    target = args.shard_mb * 1024 * 1024
+    done = skipped_nonimage = skipped_noid = skipped_corrupt = skipped_dupe = 0
+    started = time.time()
+
+    def flush() -> None:
+        nonlocal shard_no, ids, blobs, pending_bytes
+        if not ids:
+            return
+        out = args.out / f"shard-{shard_no:05d}.parquet"
+        Dataset.from_dict({"itemId": ids, "image": blobs}, features=features).to_parquet(out)
+        if not args.allow_duplicates:
+            with open(seen_path, "ab") as fh:
+                array("q", ids).tofile(fh)
+        shard_no += 1
+        rate = done / max(time.time() - started, 1e-9)
+        print(f"  wrote {out.name}  {len(ids):,} images  {human(pending_bytes)}  "
+              f"[{done:,} packed, {rate:.0f} img/s]", flush=True)
+        state_path.write_text(json.dumps({"next_shard": shard_no, "images_done": resume_from + done}))
+        pending.append(out)
+        ids, blobs, pending_bytes = [], [], 0
+
+    def push() -> None:
+        """Upload the shards built since the last push, then delete them locally."""
+        nonlocal pending
+        if not api or not pending:
+            return
+        size = sum(f.stat().st_size for f in pending)
+        print(f"  uploading {len(pending)} shard(s), {human(size)} ...", flush=True)
+        try:
+            api.upload_folder(
+                repo_id=args.upload_repo,
+                repo_type="dataset",
+                folder_path=str(args.out),
+                path_in_repo="images",
+                allow_patterns=["shard-*.parquet"],
+                commit_message=f"images: shards through {resume_from + done:,} images",
+            )
+        except HfHubHTTPError as exc:
+            sys.exit(f"upload failed: {exc}\n"
+                     "Rerun the same command -- packed shards are on disk and the build resumes.")
+        # Only reached on a successful commit. The itemIds survive in
+        # .seen_ids.bin, so deleting the shards does not weaken dedup.
+        for f in pending:
+            f.unlink()
+        print(f"  uploaded, freed {human(size)}", flush=True)
+        pending = []
+
+    for name, data in iter_members(args.source):
+        base = Path(name).name
+        # macOS `tar` writes an AppleDouble sidecar next to every file; it shares
+        # the real name, so it would otherwise claim the itemId first.
+        if base.startswith("._") or name.startswith("__MACOSX/"):
+            skipped_nonimage += 1
+            continue
+        suffix = Path(name).suffix.lower()
+        if suffix not in IMAGE_SUFFIXES:
+            skipped_nonimage += 1
+            continue
+
+        # Everything past here counts as an image, so the resume counter stays
+        # aligned with the tar order regardless of what we decide to drop.
+        if skip:
+            skip -= 1
+            continue
+
+        item_id = extract(Path(name).stem)
+        if item_id is None:
+            skipped_noid += 1
+            continue
+        if sniff(data) is None:
+            skipped_corrupt += 1
+            continue
+        if not args.allow_duplicates:
+            if item_id in seen_ids:
+                skipped_dupe += 1
+                continue
+            seen_ids.add(item_id)
+
+        ids.append(item_id)
+        blobs.append({"bytes": data, "path": f"{item_id}{suffix}"})
+        pending_bytes += len(data)
+        done += 1
+
+        if pending_bytes >= target:
+            flush()
+            if sum(f.stat().st_size for f in pending) >= args.upload_every_mb * 1024 * 1024:
+                push()
+        if args.limit and done >= args.limit:
+            break
+
+    flush()
+    push()
+
+    where = args.upload_repo or f"{args.out}/"
+    print(f"\nDone: {done:,} images this run, {shard_no} shard(s) total -> {where}")
+    for label, n in (("non-image entries", skipped_nonimage), ("no itemId in filename", skipped_noid),
+                     ("corrupt / not an image", skipped_corrupt), ("duplicate itemId", skipped_dupe)):
+        if n:
+            print(f"  skipped {n:,} -- {label}")
+    if skipped_noid or skipped_corrupt:
+        print("\nA large skip count usually means --id-regex is wrong or the crawl "
+              "saved error pages. Re-check with --inspect before uploading.")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/upload_to_hub.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""Upload this dataset to the Hugging Face Hub over HTTP.
+
+Deliberately does not use git. A 100GB+ push through git-lfs stalls, retries
+from zero, and needs a working git-lfs install (this clone does not have one).
+`upload_large_folder` is the Hub's own path for exactly this case: many
+workers, resumable, and it picks up where it left off if you rerun it.
+
+Usage:
+    hf auth login                                  # once
+    python scripts/upload_to_hub.py --dry-run      # see what would go up
+    python scripts/upload_to_hub.py                # upload shards + metadata
+    python scripts/upload_to_hub.py --only images  # shards alone
+
+Requires: pip install -U "huggingface_hub[hf_xet]"
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from fnmatch import fnmatch
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+DEFAULT_REPO = "zidcenek/GLAMIDuplicationDetection"
+
+GROUPS = {
+    "images": ["images/*.parquet"],
+    "metadata": ["*.csv", "README.md", "LICENSE"],
+}
+
+# .cache/huggingface holds upload_large_folder's own resume state; .git and the
+# source tarball must never be shipped to the Hub.
+# fnmatch's "*" crosses "/", so an allow pattern like "*.csv" sweeps up every
+# nested CSV as well -- a virtualenv inside the repo is enough to leak numpy's
+# test fixtures into a public dataset. These directories are excluded outright.
+IGNORE = [
+    ".git/*", "**/.git/*",
+    ".cache/*", "**/.cache/*",
+    ".venv/*", "**/.venv/*", "venv/*", "**/venv/*", "**/site-packages/*",
+    "*.tar.gz", "scripts/*",
+    ".build_state.json", "**/.build_state.json",
+    ".seen_ids.bin", "**/.seen_ids.bin",
+    ".DS_Store", "**/.DS_Store",
+]
+
+
+def human(n: float) -> str:
+    for unit in ("B", "KB", "MB", "GB", "TB"):
+        if n < 1024:
+            return f"{n:.1f}{unit}"
+        n /= 1024
+    return f"{n:.1f}PB"
+
+
+def matching_files(root: Path, patterns: list[str]) -> list[Path]:
+    hits = []
+    for path in root.rglob("*"):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(root).as_posix()
+        if any(fnmatch(rel, pat) for pat in IGNORE) or rel.startswith(".git/"):
+            continue
+        if any(fnmatch(rel, pat) for pat in patterns):
+            hits.append(path)
+    return sorted(hits)
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    p.add_argument("--repo-id", default=DEFAULT_REPO)
+    p.add_argument("--root", type=Path, default=REPO_ROOT)
+    p.add_argument("--only", choices=sorted(GROUPS), action="append",
+                   help="upload just one group (repeatable); default is all of them")
+    p.add_argument("--workers", type=int, default=8,
+                   help="parallel upload workers (default: 8; lower it if your uplink saturates)")
+    p.add_argument("--dry-run", action="store_true", help="list the files and exit")
+    p.add_argument("--yes", "-y", action="store_true", help="skip the confirmation prompt")
+    args = p.parse_args()
+
+    from huggingface_hub import HfApi
+    from huggingface_hub.utils import HfHubHTTPError
+
+    try:
+        import hf_xet  # noqa: F401
+    except ImportError:
+        print("note: hf_xet is not installed. Install it -- 'pip install -U \"huggingface_hub[hf_xet]\"' --\n"
+              "      for chunk-level deduplication, which matters a lot for a near-duplicate image set.\n")
+
+    patterns = [pat for group in (args.only or sorted(GROUPS)) for pat in GROUPS[group]]
+    files = matching_files(args.root, patterns)
+    if not files:
+        sys.exit(f"nothing matches {patterns} under {args.root} -- build the shards first")
+
+    suspicious = [f for f in files
+                  if any(part.startswith(".") or part in {"site-packages", "node_modules"}
+                         for part in f.relative_to(args.root).parts[:-1])]
+    if suspicious:
+        print("refusing to upload -- these matched from inside a hidden or vendored directory:")
+        for f in suspicious[:10]:
+            print(f"          {f.relative_to(args.root).as_posix()}")
+        sys.exit("widen IGNORE in this script, or move that directory out of the repo")
+
+    total = sum(f.stat().st_size for f in files)
+    print(f"repo    {args.repo_id}  (dataset)")
+    print(f"root    {args.root}")
+    print(f"files   {len(files):,}  totalling {human(total)}")
+    for f in files[:6]:
+        print(f"          {f.relative_to(args.root).as_posix()}  {human(f.stat().st_size)}")
+    if len(files) > 6:
+        print(f"          ... and {len(files) - 6:,} more")
+
+    stubs = [f for f in files if f.suffix == ".csv" and f.stat().st_size < 200]
+    if stubs:
+        print("\nWARNING: these CSVs are 134-byte git-lfs pointer stubs, not real data.")
+        for f in stubs:
+            print(f"          {f.relative_to(args.root).as_posix()}")
+        print("         Uploading them would overwrite the real files on the Hub.")
+        print("         Install git-lfs and run 'git lfs pull' first, or exclude them.")
+        if not args.yes:
+            sys.exit("aborting -- rerun with --only images, or fix the stubs")
+
+    if args.dry_run:
+        return 0
+
+    api = HfApi()
+    try:
+        who = api.whoami()
+    except Exception:
+        sys.exit("not authenticated -- run 'hf auth login' first")
+    print(f"user    {who['name']}")
+
+    if not args.yes:
+        if input("\nupload? [y/N] ").strip().lower() not in {"y", "yes"}:
+            return 1
+
+    try:
+        api.upload_large_folder(
+            repo_id=args.repo_id,
+            repo_type="dataset",
+            folder_path=str(args.root),
+            allow_patterns=patterns,
+            ignore_patterns=IGNORE,
+            num_workers=args.workers,
+            print_report=True,
+        )
+    except HfHubHTTPError as exc:
+        sys.exit(f"upload failed: {exc}\nRerun the same command -- it resumes from where it stopped.")
+
+    print(f"\nDone: https://huggingface.co/datasets/{args.repo_id}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())