Datasets:

Jyo-K
/

PopTurk

"""Hugging Face transport for the payload repo.
WHY A PAYLOAD REPO. Colab cannot see the college box and the college box cannot push into a
Colab VM. Everything both sides need therefore has to live somewhere both can reach. The three
embedding repos already exist; this module manages a fourth repo that carries the *small*
things: raw text, candidate shards, model checkpoints and this source tree.
PRIVACY. The competition data is licensed to participants, not to the public. Every upload
here defaults to a PRIVATE repo and `ensure_repo` will refuse to create a public one unless
`public=True` is passed explicitly. Do not change that default.
"""
from __future__ import annotations

import os
import sys

# ---------------------------------------------------------------- credentials
# Put your token here so nothing has to be exported before every command.
#
#   HF_TOKEN = "hf_PASTE_YOURS"
#
# (That example is deliberately too short to match the leak detector below. A realistic
# dummy in a comment would trip the guard and refuse every upload.)
#
# TWO THINGS THIS FILE DOES TO KEEP THAT SAFE, because a token written into source is one
# copy away from being published:
#   1. `push_code` REDACTS this constant before uploading the source tree to the payload
#      repo. Without that, the first `--what code` upload would publish your token inside
#      the very dataset repo it authenticates to. The redaction is asserted, not assumed.
#   2. `token_source()` reports where the token came from, so a surprising one is visible.
#
# It is still a secret in a file on a box 26 other people can log into. Prefer
# `--token` or the environment if you ever share this directory, and rotate it when the
# competition is over.
HF_TOKEN = ""  # redacted for upload

_TOKEN_ENV = ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN", "HUGGINGFACE_TOKEN")
_TOKEN_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
                           "hf_token.txt")
_OVERRIDE: str | None = None


def set_token(tok: str) -> None:
    """Used by --token, which beats every other source."""
    global _OVERRIDE
    _OVERRIDE = tok.strip() or None


def token() -> str | None:
    if _OVERRIDE:
        return _OVERRIDE
    if HF_TOKEN.strip():
        return HF_TOKEN.strip()
    if os.path.exists(_TOKEN_FILE):
        v = open(_TOKEN_FILE, encoding="utf-8").read().strip()
        if v:
            return v
    for k in _TOKEN_ENV:
        v = os.environ.get(k)
        if v:
            return v
    return None


def token_source() -> str:
    if _OVERRIDE:
        return "--token"
    if HF_TOKEN.strip():
        return "berx/io_hf.py:HF_TOKEN"
    if os.path.exists(_TOKEN_FILE) and open(_TOKEN_FILE, encoding="utf-8").read().strip():
        return _TOKEN_FILE
    for k in _TOKEN_ENV:
        if os.environ.get(k):
            return f"${k}"
    return "none"


def _api():
    from huggingface_hub import HfApi
    return HfApi(token=token())


def ensure_repo(repo_id: str, public: bool = False) -> str:
    """Create the dataset repo if it does not exist. Private unless asked otherwise."""
    from huggingface_hub.utils import HfHubHTTPError
    api = _api()
    try:
        api.create_repo(repo_id, repo_type="dataset", private=not public, exist_ok=True)
    except HfHubHTTPError as e:                      # already exists under another owner, etc.
        print(f"  create_repo: {e}", file=sys.stderr)
    return repo_id


def upload(local_path: str, path_in_repo: str, repo_id: str, public: bool = False) -> str:
    """Upload one file or one directory. Returns the path in the repo."""
    ensure_repo(repo_id, public)
    api = _api()
    if os.path.isdir(local_path):
        api.upload_folder(folder_path=local_path, path_in_repo=path_in_repo,
                          repo_id=repo_id, repo_type="dataset")
    else:
        api.upload_file(path_or_fileobj=local_path, path_in_repo=path_in_repo,
                        repo_id=repo_id, repo_type="dataset")
    return path_in_repo


def fetch(path_in_repo: str, repo_id: str, local_dir: str | None = None) -> str:
    """Download one file from the payload repo and return its local path."""
    from huggingface_hub import hf_hub_download
    return hf_hub_download(repo_id=repo_id, filename=path_in_repo, repo_type="dataset",
                           local_dir=local_dir, token=token())


def fetch_dir(repo_id: str, allow: list[str] | None = None,
              local_dir: str | None = None) -> str:
    """Download a subset of a repo. `allow` is a list of glob patterns.
    Always pass `allow`. The embedding repos hold tens of gigabytes and a bare
    snapshot_download of one of them will fill a Colab disk before it finishes.
    """
    from huggingface_hub import snapshot_download
    return snapshot_download(repo_id=repo_id, repo_type="dataset", allow_patterns=allow,
                             local_dir=local_dir, token=token(),
                             max_workers=8)

	"""Hugging Face transport for the payload repo.

	WHY A PAYLOAD REPO. Colab cannot see the college box and the college box cannot push into a
	Colab VM. Everything both sides need therefore has to live somewhere both can reach. The three
	embedding repos already exist; this module manages a fourth repo that carries the small
	things: raw text, candidate shards, model checkpoints and this source tree.

	PRIVACY. The competition data is licensed to participants, not to the public. Every upload
	here defaults to a PRIVATE repo and `ensure_repo` will refuse to create a public one unless
	`public=True` is passed explicitly. Do not change that default.
	"""
	from __future__ import annotations

	import os
	import sys

	# ---------------------------------------------------------------- credentials
	# Put your token here so nothing has to be exported before every command.
	#
	# HF_TOKEN = "hf_PASTE_YOURS"
	#
	# (That example is deliberately too short to match the leak detector below. A realistic
	# dummy in a comment would trip the guard and refuse every upload.)
	#
	# TWO THINGS THIS FILE DOES TO KEEP THAT SAFE, because a token written into source is one
	# copy away from being published:
	# 1. `push_code` REDACTS this constant before uploading the source tree to the payload
	# repo. Without that, the first `--what code` upload would publish your token inside
	# the very dataset repo it authenticates to. The redaction is asserted, not assumed.
	# 2. `token_source()` reports where the token came from, so a surprising one is visible.
	#
	# It is still a secret in a file on a box 26 other people can log into. Prefer
	# `--token` or the environment if you ever share this directory, and rotate it when the
	# competition is over.
	HF_TOKEN = "" # redacted for upload

	_TOKEN_ENV = ("HF_TOKEN", "HUGGING_FACE_HUB_TOKEN", "HUGGINGFACE_TOKEN")
	_TOKEN_FILE = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
	"hf_token.txt")
	_OVERRIDE: str \| None = None


	def set_token(tok: str) -> None:
	"""Used by --token, which beats every other source."""
	global _OVERRIDE
	_OVERRIDE = tok.strip() or None


	def token() -> str \| None:
	if _OVERRIDE:
	return _OVERRIDE
	if HF_TOKEN.strip():
	return HF_TOKEN.strip()
	if os.path.exists(_TOKEN_FILE):
	v = open(_TOKEN_FILE, encoding="utf-8").read().strip()
	if v:
	return v
	for k in _TOKEN_ENV:
	v = os.environ.get(k)
	if v:
	return v
	return None


	def token_source() -> str:
	if _OVERRIDE:
	return "--token"
	if HF_TOKEN.strip():
	return "berx/io_hf.py:HF_TOKEN"
	if os.path.exists(_TOKEN_FILE) and open(_TOKEN_FILE, encoding="utf-8").read().strip():
	return _TOKEN_FILE
	for k in _TOKEN_ENV:
	if os.environ.get(k):
	return f"${k}"
	return "none"


	def _api():
	from huggingface_hub import HfApi
	return HfApi(token=token())


	def ensure_repo(repo_id: str, public: bool = False) -> str:
	"""Create the dataset repo if it does not exist. Private unless asked otherwise."""
	from huggingface_hub.utils import HfHubHTTPError
	api = _api()
	try:
	api.create_repo(repo_id, repo_type="dataset", private=not public, exist_ok=True)
	except HfHubHTTPError as e: # already exists under another owner, etc.
	print(f" create_repo: {e}", file=sys.stderr)
	return repo_id


	def upload(local_path: str, path_in_repo: str, repo_id: str, public: bool = False) -> str:
	"""Upload one file or one directory. Returns the path in the repo."""
	ensure_repo(repo_id, public)
	api = _api()
	if os.path.isdir(local_path):
	api.upload_folder(folder_path=local_path, path_in_repo=path_in_repo,
	repo_id=repo_id, repo_type="dataset")
	else:
	api.upload_file(path_or_fileobj=local_path, path_in_repo=path_in_repo,
	repo_id=repo_id, repo_type="dataset")
	return path_in_repo


	def fetch(path_in_repo: str, repo_id: str, local_dir: str \| None = None) -> str:
	"""Download one file from the payload repo and return its local path."""
	from huggingface_hub import hf_hub_download
	return hf_hub_download(repo_id=repo_id, filename=path_in_repo, repo_type="dataset",
	local_dir=local_dir, token=token())


	def fetch_dir(repo_id: str, allow: list[str] \| None = None,
	local_dir: str \| None = None) -> str:
	"""Download a subset of a repo. `allow` is a list of glob patterns.

	Always pass `allow`. The embedding repos hold tens of gigabytes and a bare
	snapshot_download of one of them will fill a Colab disk before it finishes.
	"""
	from huggingface_hub import snapshot_download
	return snapshot_download(repo_id=repo_id, repo_type="dataset", allow_patterns=allow,
	local_dir=local_dir, token=token(),
	max_workers=8)