Upload tecd_downloader.py

tecd_downloader.py

@@ -0,0 +1,270 @@
+#!/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()