import os import tempfile import zipfile import zarr import numpy as np from typing import Dict, List, Any, Optional import datasets from datasets import DownloadManager, DatasetInfo, Split, SplitGenerator, Features, Value, Array2D, Array3D import fsspec from pathlib import Path class TestDownloadManager(datasets.DownloadManager): """Custom download manager that handles zarr chunks in zip format for streaming.""" def __init__(self, dataset_name: str = "test", cache_dir: Optional[str] = None): # Initialize parent without cache_dir parameter since it may not accept it super().__init__() self.dataset_name = dataset_name # Set cache_dir manually if provided if cache_dir: self.cache_dir = cache_dir elif not hasattr(self, 'cache_dir') or self.cache_dir is None: # Fallback to default cache directory import tempfile self.cache_dir = tempfile.gettempdir() def download_zarr_chunks(self, traces_path: str, chunk_size: int = 100) -> str: """ Convert traces.npy to zarr format with chunks and store in zip file. Returns path to the zip file containing zarr chunks. """ # Load the original traces data traces = np.load(traces_path) # Create temporary directory for zarr store temp_dir = tempfile.mkdtemp() zarr_path = os.path.join(temp_dir, "traces.zarr") zip_path = os.path.join(temp_dir, "traces_zarr.zip") # Create zarr array with chunking using zarr v2 format chunks = (chunk_size, traces.shape[1]) # Chunk along the first dimension zarr_array = zarr.open(zarr_path, mode='w', shape=traces.shape, chunks=chunks, dtype=traces.dtype) # Write data in chunks for i in range(0, traces.shape[0], chunk_size): end_idx = min(i + chunk_size, traces.shape[0]) zarr_array[i:end_idx] = traces[i:end_idx] # Create zip file with zarr store - include the zarr directory structure with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf: for root, dirs, files in os.walk(zarr_path): for file in files: file_path = os.path.join(root, file) # Keep the zarr directory structure in the zip arcname = os.path.relpath(file_path, temp_dir) zipf.write(file_path, arcname) # Move to cache directory cache_path = os.path.join(self.cache_dir, f"{self.dataset_name}_traces_zarr.zip") os.makedirs(os.path.dirname(cache_path), exist_ok=True) # Copy to cache if not exists or if source is newer if not os.path.exists(cache_path) or os.path.getmtime(zip_path) > os.path.getmtime(cache_path): import shutil shutil.copy2(zip_path, cache_path) return cache_path class TestDataset(datasets.GeneratorBasedBuilder): """Custom dataset for DLSCA test data with streaming zarr support.""" VERSION = datasets.Version("1.0.0") def _info(self) -> DatasetInfo: """Define the dataset information and features.""" return DatasetInfo( description="DLSCA test dataset with streaming support for large traces", features=Features({ "labels": datasets.Sequence(datasets.Value("int32"), length=4), "traces": datasets.Sequence(datasets.Value("int8"), length=20971), "index": Value("int32"), }), supervised_keys=("traces", "labels"), homepage="https://huggingface.co/datasets/DLSCA/test", ) def _split_generators(self, dl_manager: DownloadManager) -> List[SplitGenerator]: """Define the data splits.""" # Use custom download manager if available, otherwise use standard paths if isinstance(dl_manager, TestDownloadManager): # For remote/cached access data_dir = os.path.join(os.path.dirname(__file__), "data") labels_path = os.path.join(data_dir, "labels.npy") # Convert and cache zarr chunks traces_path = os.path.join(data_dir, "traces.npy") zarr_zip_path = dl_manager.download_zarr_chunks(traces_path) else: # For local development data_dir = os.path.join(os.path.dirname(__file__), "data") labels_path = os.path.join(data_dir, "labels.npy") traces_path = os.path.join(data_dir, "traces.npy") zarr_zip_path = None return [ SplitGenerator( name=Split.TRAIN, gen_kwargs={ "labels_path": labels_path, "traces_path": traces_path, "zarr_zip_path": zarr_zip_path, }, ), ] def _generate_examples(self, labels_path: str, traces_path: str, zarr_zip_path: Optional[str] = None): """Generate examples from the dataset.""" # Load labels (small file, can load entirely) labels = np.load(labels_path) if zarr_zip_path and os.path.exists(zarr_zip_path): # Use zarr from zip for streaming access traces_array = self._load_zarr_from_zip(zarr_zip_path) else: # Fallback to numpy array for local development traces_array = np.load(traces_path) # Generate examples for idx in range(len(labels)): yield idx, { "labels": labels[idx], "traces": traces_array[idx] if zarr_zip_path else traces_array[idx], "index": idx, } def _load_zarr_from_zip(self, zip_path: str) -> zarr.Array: """Load zarr array from zip file with streaming support.""" # Create a filesystem that can read from zip fs = fsspec.filesystem('zip', fo=zip_path) # Open zarr array through the zip filesystem mapper = fs.get_mapper('traces.zarr') zarr_array = zarr.open(mapper, mode='r') return zarr_array def _get_chunk_indices(self, start_idx: int, end_idx: int, chunk_size: int = 100) -> List[tuple]: """Helper method to get chunk indices for streaming access.""" chunks = [] current_idx = start_idx while current_idx < end_idx: chunk_start = (current_idx // chunk_size) * chunk_size chunk_end = min(chunk_start + chunk_size, end_idx) chunks.append((chunk_start, chunk_end)) current_idx = chunk_end return chunks # Utility functions for dataset usage def get_dataset_info(): """Get information about the dataset.""" dataset = TestDataset() info = { "description": "DLSCA test dataset with streaming support", "total_examples": 1000, "features": { "labels": {"shape": (4,), "dtype": "int32"}, "traces": {"shape": (20971,), "dtype": "int8"}, "index": {"dtype": "int32"} }, "splits": ["train"], "size_info": { "labels_file": "~16KB", "traces_file": "~20MB", "zarr_chunks": "10 chunks of 100 examples each" } } return info def create_data_loader(zarr_zip_path: str, batch_size: int = 32, shuffle: bool = True): """Create a data loader for the zarr dataset.""" dataset = TestDataset() zarr_array = dataset._load_zarr_from_zip(zarr_zip_path) labels = np.load(os.path.join(os.path.dirname(__file__), "data", "labels.npy")) # Simple batch generator def batch_generator(): indices = list(range(len(labels))) if shuffle: import random random.shuffle(indices) for i in range(0, len(indices), batch_size): batch_indices = indices[i:i+batch_size] batch_traces = zarr_array[batch_indices] batch_labels = labels[batch_indices] yield { "traces": batch_traces, "labels": batch_labels, "indices": batch_indices } return batch_generator def validate_dataset_integrity(): """Validate that zarr conversion preserves data integrity.""" # Load original data original_traces = np.load(os.path.join(os.path.dirname(__file__), "data", "traces.npy")) original_labels = np.load(os.path.join(os.path.dirname(__file__), "data", "labels.npy")) # Convert to zarr and load back dl_manager = TestDownloadManager() traces_path = os.path.join(os.path.dirname(__file__), "data", "traces.npy") zarr_zip_path = dl_manager.download_zarr_chunks(traces_path) dataset = TestDataset() zarr_traces = dataset._load_zarr_from_zip(zarr_zip_path) # Validate traces_match = np.array_equal(original_traces, zarr_traces[:]) shapes_match = original_traces.shape == zarr_traces.shape dtypes_match = original_traces.dtype == zarr_traces.dtype validation_results = { "traces_data_match": traces_match, "shapes_match": shapes_match, "dtypes_match": dtypes_match, "original_shape": original_traces.shape, "zarr_shape": zarr_traces.shape, "original_dtype": str(original_traces.dtype), "zarr_dtype": str(zarr_traces.dtype), "zarr_chunks": zarr_traces.chunks } return validation_results # Additional convenience functions for Hugging Face Hub integration def prepare_for_hub_upload(): """Prepare dataset files for Hugging Face Hub upload.""" print("Preparing dataset for Hugging Face Hub upload...") # Validate dataset integrity validation = validate_dataset_integrity() if not all([validation["traces_data_match"], validation["shapes_match"], validation["dtypes_match"]]): raise ValueError("Dataset validation failed!") # Get dataset info info = get_dataset_info() print("✅ Dataset validation passed") print(f"✅ Total examples: {info['total_examples']}") print(f"✅ Features: {list(info['features'].keys())}") print(f"✅ Zarr chunks: {validation['zarr_chunks']}") return { "validation": validation, "info": info, "ready_for_upload": True } # Example usage if __name__ == "__main__": # For local testing print("Loading dataset locally...") dataset = TestDataset() # Download and prepare the dataset first print("Downloading and preparing dataset...") dataset.download_and_prepare() # Build dataset dataset_dict = dataset.as_dataset(split="train") print(f"Dataset size: {len(dataset_dict)}") print(f"Features: {dataset_dict.features}") # Show first example first_example = dataset_dict[0] print(f"First example - Labels length: {len(first_example['labels'])}") print(f"First example - Traces length: {len(first_example['traces'])}") print(f"First example - Labels: {first_example['labels']}") print(f"First example - Index: {first_example['index']}") # Test zarr conversion print("\nTesting zarr conversion...") dl_manager = TestDownloadManager() traces_path = os.path.join(os.path.dirname(__file__), "data", "traces.npy") zarr_zip_path = dl_manager.download_zarr_chunks(traces_path, chunk_size=100) print(f"Zarr zip created at: {zarr_zip_path}") # Test loading from zarr zip test_dataset_zarr = TestDataset() zarr_array = test_dataset_zarr._load_zarr_from_zip(zarr_zip_path) print(f"Zarr array shape: {zarr_array.shape}") print(f"Zarr array dtype: {zarr_array.dtype}") print(f"Zarr array chunks: {zarr_array.chunks}") # Verify data integrity original_traces = np.load(traces_path) print(f"Data integrity check: {np.array_equal(original_traces, zarr_array[:])}") print("\n=== Dataset Utilities Test ===") # Test dataset info info = get_dataset_info() print(f"Dataset info: {info['total_examples']} examples") # Test validation validation = validate_dataset_integrity() print(f"Validation passed: {validation['traces_data_match']}") # Test data loader dl_manager = TestDownloadManager() traces_path = os.path.join(os.path.dirname(__file__), "data", "traces.npy") zarr_zip_path = dl_manager.download_zarr_chunks(traces_path) batch_gen = create_data_loader(zarr_zip_path, batch_size=16) first_batch = next(batch_gen()) print(f"First batch shape: traces={first_batch['traces'].shape}, labels={first_batch['labels'].shape}") # Test hub preparation hub_status = prepare_for_hub_upload() print(f"Ready for Hub upload: {hub_status['ready_for_upload']}") print("\n✅ All utilities working correctly!")