tecd_downloader.py

#!/usr/bin/env python3
"""
T-ECD Dataset Downloader
Supports selective downloading by domains and date ranges.
"""

import argparse
import concurrent.futures
import os
import sys
from dataclasses import dataclass
from getpass import getpass
from pathlib import Path
from typing import List, Tuple

import polars as pl
from huggingface_hub import snapshot_download
from tqdm import tqdm


@dataclass
class DownloadConfig:
    """Configuration for dataset download parameters."""

    token: str
    dataset_path: str = "dataset/full"
    local_dir: str = "t_ecd_full"
    domains: Tuple[str, ...] = (
        "retail",
        "marketplace",
        "offers",
        "reviews",
        "payments",
    )
    day_begin: int = 0
    day_end: int = 1308  # inclusive
    max_workers: int = 20


class DatasetDownloader:
    """Handles downloading of T-ECD dataset."""

    STATIC_FILES = ["users.pq", "brands.pq"]
    DOMAIN_ITEMS = ["retail", "marketplace", "offers"]
    ALL_DOMAINS = ["retail", "marketplace", "offers", "reviews", "payments"]

    def __init__(self, config: DownloadConfig):
        self.config = config
        self._ensure_local_dir()

    def _ensure_local_dir(self) -> None:
        """Create local directory if it doesn't exist."""
        Path(self.config.local_dir).mkdir(parents=True, exist_ok=True)

    def _generate_file_patterns(self) -> List[str]:
        """Generate all file patterns to download based on configuration."""
        patterns = []

        # Add static files
        patterns.extend(
            f"{self.config.dataset_path}/{file}" for file in self.STATIC_FILES
        )

        # Add domain-specific item files
        patterns.extend(
            f"{self.config.dataset_path}/{domain}/items.pq"
            for domain in self.config.domains
            if domain in self.DOMAIN_ITEMS
        )

        # Add daily files for each domain
        for domain in self.config.domains:
            for day in range(self.config.day_begin, self.config.day_end + 1):
                day_str = str(day).zfill(5)
                patterns.extend(self._get_domain_day_patterns(domain, day_str))

        return patterns

    def _get_domain_day_patterns(self, domain: str, day_str: str) -> List[str]:
        """Get file patterns for a specific domain and day."""
        base_path = f"{self.config.dataset_path}/{domain}"

        if domain in ["retail", "marketplace", "offers"]:
            return [f"{base_path}/events/{day_str}.pq"]
        elif domain == "payments":
            return [
                f"{base_path}/events/{day_str}.pq",
                f"{base_path}/receipts/{day_str}.pq",
            ]
        elif domain == "reviews":
            return [f"{base_path}/{day_str}.pq"]

        return []

    def _download_single_file(self, pattern: str) -> Tuple[str, bool]:
        """Download a single file."""
        try:
            snapshot_download(
                repo_id="t-tech/T-ECD",
                repo_type="dataset",
                allow_patterns=pattern,
                local_dir=self.config.local_dir,
                token=self.config.token,
            )
            return pattern, True
        except Exception as e:
            print(f"Error downloading {pattern}: {e}")
            return pattern, False

    def download(self) -> List[str]:
        """Download all specified files in parallel.

        Returns:
            List of failed download patterns
        """
        patterns = self._generate_file_patterns()
        print(f"Downloading {len(patterns)} files to {self.config.local_dir}")

        with concurrent.futures.ThreadPoolExecutor(
            max_workers=self.config.max_workers
        ) as executor:
            # Submit all download tasks
            future_to_pattern = {
                executor.submit(self._download_single_file, pattern): pattern
                for pattern in patterns
            }

            # Process results with progress bar
            results = []
            for future in tqdm(
                concurrent.futures.as_completed(future_to_pattern),
                total=len(patterns),
                desc="Downloading files",
            ):
                results.append(future.result())

        # Report results
        successful = sum(1 for _, status in results if status)
        failed = [pattern for pattern, status in results if not status]

        print(f"Download completed: {successful}/{len(patterns)} files successful")

        if failed:
            print("Failed downloads:")
            for pattern in sorted(failed):
                print(f"  - {pattern}")

        return failed


def create_config_from_args(args) -> DownloadConfig:
    """Create DownloadConfig from command line arguments."""
    token = args.token or os.getenv("HF_TOKEN")
    if not token:
        token = getpass("Enter your Hugging Face token: ")

    domains = args.domains if args.domains else DatasetDownloader.ALL_DOMAINS

    return DownloadConfig(
        token=token,
        dataset_path=args.dataset_path,
        local_dir=args.local_dir,
        domains=tuple(domains),
        day_begin=args.day_begin,
        day_end=args.day_end,
        max_workers=args.max_workers,
    )


def download_dataset(
    token: str,
    local_dir: str = "t_ecd_full",
    dataset_path: str = "dataset/full",
    domains: List[str] = None,
    day_begin: int = 1307,
    day_end: int = 1308,
    max_workers: int = 20,
) -> List[str]:
    """High-level function to download T-ECD dataset.

    Args:
        token: Hugging Face authentication token
        local_dir: Local directory to save dataset
        dataset_path: Path within the dataset repository
        domains: List of domains to download
        day_begin: Start day (inclusive)
        day_end: End day (inclusive)
        max_workers: Number of parallel download workers

    Returns:
        List of failed download patterns
    """
    if domains is None:
        domains = DatasetDownloader.ALL_DOMAINS

    config = DownloadConfig(
        token=token,
        local_dir=local_dir,
        dataset_path=dataset_path,
        domains=tuple(domains),
        day_begin=day_begin,
        day_end=day_end,
        max_workers=max_workers,
    )

    downloader = DatasetDownloader(config)
    return downloader.download()


def main():
    """Main execution function."""
    parser = argparse.ArgumentParser(
        description="Download T-ECD dataset from Hugging Face Hub"
    )
    parser.add_argument(
        "--token", "-t", help="Hugging Face token (or set HF_TOKEN env var)"
    )
    parser.add_argument(
        "--local-dir",
        "-d",
        default="t_ecd_full",
        help="Local directory to save dataset",
    )
    parser.add_argument(
        "--dataset-path",
        "-p",
        default="dataset/full",
        help="Path within the dataset repository",
    )
    parser.add_argument(
        "--domains",
        "-m",
        nargs="+",
        choices=DatasetDownloader.ALL_DOMAINS,
        help="Domains to download (default: all)",
    )
    parser.add_argument(
        "--day-begin", "-b", type=int, default=1307, help="Start day (inclusive)"
    )
    parser.add_argument(
        "--day-end", "-e", type=int, default=1308, help="End day (inclusive)"
    )
    parser.add_argument(
        "--max-workers",
        "-w",
        type=int,
        default=20,
        help="Number of parallel download workers",
    )

    args = parser.parse_args()

    try:
        config = create_config_from_args(args)
        downloader = DatasetDownloader(config)
        failed_downloads = downloader.download()

        exit_code = 1 if failed_downloads else 0
        sys.exit(exit_code)

    except KeyboardInterrupt:
        print("\nDownload cancelled by user")
        sys.exit(1)
    except Exception as e:
        print(f"Fatal error: {e}")
        sys.exit(1)


if __name__ == "__main__":
    main()