Update WABAD.py

WABAD.py

@@ -2,54 +2,6 @@ import datasets
 import pandas as pd
 import os
 import ast
-import zipfile
-from pathlib import Path
-
-
-def _extract_zip_to_folder(zip_path, output_dir):
-    """Extract zip file to output directory, similar to BirdSet's tar extraction"""
-    # Check if data already exists
-    if not os.path.isfile(output_dir) and os.path.isdir(output_dir) and os.listdir(output_dir):
-        return output_dir
-    
-    os.makedirs(output_dir, exist_ok=True)
-    
-    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
-        for member in zip_ref.infolist():
-            if not member.is_dir():
-                # Extract file to output directory
-                member.filename = os.path.basename(member.filename)
-                zip_ref.extract(member, path=output_dir)
-    
-    return output_dir
-
-
-def _extract_and_delete_zip(dl_dir: dict, cache_dir: str = None) -> dict:
-    """Extract downloaded zip files and delete archives immediately, similar to BirdSet"""
-    audio_paths = {name: [] for name, data in dl_dir.items() if name.startswith('audio_')}
-    
-    for name, data in dl_dir.items():
-        if not name.startswith('audio_'):
-            continue
-            
-        # Extract zip file
-        directory, filename = os.path.split(data)
-        output_dir = os.path.join(cache_dir or directory, "extracted", filename.split(".")[0])
-        audio_path = _extract_zip_to_folder(data, output_dir)
-        
-        # Clean up
-        os.remove(data)
-        # Remove lock files if they exist (datasets >3.0.0)
-        if os.path.exists(f"{data}.lock"):
-            os.remove(f"{data}.lock")
-        if os.path.exists(f"{data}.json"):
-            os.remove(f"{data}.json")
-            
-        # Store the base name without 'audio_' prefix
-        base_name = name.replace('audio_', '')
-        audio_paths[base_name] = audio_path
-    
-    return audio_paths
 
 
 class WABADBuilderConfig(datasets.BuilderConfig):
@@ -57,160 +9,64 @@ class WABADBuilderConfig(datasets.BuilderConfig):
         super().__init__(**kwargs)
         self.location_dir = location_dir
 
-
 class WABADDataset(datasets.GeneratorBasedBuilder):
-    """WABAD: World Acoustic Bird Audio Dataset"""
-    
-    # Batch size to prevent memory issues
-    DEFAULT_WRITER_BATCH_SIZE = 500
-    
     BUILDER_CONFIGS = [
-        WABADBuilderConfig(name="BUR", location_dir="BUR", description="BUR location"),
-        # Add more locations here as needed
+        WABADBuilderConfig(name="BAM", location_dir="BAM", description="BAM location"),
+        WABADBuilderConfig(name="ARD", location_dir="ARD", description="ARD location"),
+        # add more locations here
     ]
 
     def _info(self):
         return datasets.DatasetInfo(
-            description="WABAD: World Acoustic Bird Audio Dataset",
             features=datasets.Features({
-                "audio": datasets.Audio(sampling_rate=48_000, mono=True, decode=False),
-                "filename": datasets.Value("string"),
-                "filepath": datasets.Value("string"),
+                "audio": datasets.Audio(), 
                 "labels": datasets.Sequence(datasets.Value("int32")),
-                "species": datasets.Sequence(datasets.Value("string")),
                 "site_ID": datasets.Value("string"),
-                "study_area": datasets.Value("string"),
-                "recording_location": datasets.Value("string"),
-                "biome": datasets.Value("string"),
-                "latitude": datasets.Value("string"),
-                "longitude": datasets.Value("string"),
-                "recorder": datasets.Value("string"),
-                "omnidirectional": datasets.Value("string"),
-                "sampling_rate": datasets.Value("string"),
-                "recording_date": datasets.Value("string"),
-                "min_annotated": datasets.Value("int32"),
-                "contact": datasets.Value("string"),
-                "reference": datasets.Value("string"),
+                # any other metadata
             })
         )
 
     def _split_generators(self, dl_manager):
         config_dir = self.config.location_dir
-        base_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}"
         
-        # Download metadata and audio files
-        dl_dir = dl_manager.download({
-            "meta_train": f"{base_url}/{config_dir}_metadata_train.parquet",
-            "meta_test": f"{base_url}/{config_dir}_metadata_test.parquet",
-            "audio_train": f"{base_url}/audio.zip",  # Assuming same zip for both splits
-            "audio_test": f"{base_url}/audio.zip",
-        })
-        
-        # Extract zip files and clean up
-        audio_paths = _extract_and_delete_zip(dl_dir, dl_manager.download_config.cache_dir) if not dl_manager.is_streaming else {}
+        # Use the correct dataset URL format and download specific files
+        train_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/{config_dir}_metadata_train.parquet"
+        test_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/{config_dir}_metadata_test.parquet"
         
+        # Download the parquet files
+        train_file = dl_manager.download(train_url)
+        test_file = dl_manager.download(test_url)
+
         return [
             datasets.SplitGenerator(
                 name=datasets.Split.TRAIN,
                 gen_kwargs={
-                    "audio_archive_iterator": dl_manager.iter_archive(dl_dir["audio_train"]) if dl_manager.is_streaming else None,
-                    "audio_extracted_path": audio_paths.get("train") if not dl_manager.is_streaming else None,
-                    "meta_path": dl_dir["meta_train"],
-                    "split": "train"
+                    "parquet_file": train_file,
+                    "config_dir": config_dir
                 },
             ),
             datasets.SplitGenerator(
                 name=datasets.Split.TEST,
                 gen_kwargs={
-                    "audio_archive_iterator": dl_manager.iter_archive(dl_dir["audio_test"]) if dl_manager.is_streaming else None,
-                    "audio_extracted_path": audio_paths.get("test") if not dl_manager.is_streaming else None,
-                    "meta_path": dl_dir["meta_test"],
-                    "split": "test"
+                    "parquet_file": test_file,
+                    "config_dir": config_dir
                 },
             )
         ]
 
-    def _generate_examples(self, audio_archive_iterator, audio_extracted_path, meta_path, split):
-        # Load metadata
-        metadata = pd.read_parquet(meta_path)
-        if metadata.index.name != "filename":
-            # Set filename as index for easier lookup
-            if "filename" in metadata.columns:
-                metadata.index = metadata["filename"]
-            else:
-                # Fallback: extract filename from filepath
-                metadata.index = metadata["filepath"].apply(lambda x: os.path.basename(x))
+    def _generate_examples(self, parquet_file, config_dir):
+        df = pd.read_parquet(parquet_file)
+        for idx, row in df.iterrows():
+            # Download audio file on demand
+            audio_url = f"https://huggingface.co/datasets/benmcewen/WABAD/resolve/main/{config_dir}/audio/{os.path.basename(row['filepath'])}"
 
-        idx = 0
-        
-        # Handle streaming case
-        if audio_archive_iterator:
-            for audio_path_in_archive, audio_file in audio_archive_iterator:
-                file_name = os.path.basename(audio_path_in_archive)
-                
-                # Find matching metadata rows
-                if file_name in metadata.index:
-                    rows = metadata.loc[[file_name]] if isinstance(metadata.loc[file_name], pd.Series) else metadata.loc[metadata.index == file_name]
-                    audio_bytes = audio_file.read()
-                    
-                    for _, row in (rows.to_frame().T if isinstance(rows, pd.Series) else rows).iterrows():
-                        yield idx, self._metadata_from_row(row, audio_bytes=audio_bytes)
-                        idx += 1
-        
-        # Handle non-streaming case
-        elif audio_extracted_path:
-            audio_files = os.listdir(audio_extracted_path)
+            labels = row["labels"]
+            if isinstance(labels, str):
+                labels = ast.literal_eval(labels) 
             
-            for audio_file in audio_files:
-                if audio_file in metadata.index:
-                    row_data = metadata.loc[audio_file]
-                    
-                    # Handle case where there might be multiple rows for same filename
-                    if isinstance(row_data, pd.DataFrame):
-                        for _, row in row_data.iterrows():
-                            audio_path = os.path.join(audio_extracted_path, audio_file)
-                            yield idx, self._metadata_from_row(row, audio_path=audio_path)
-                            idx += 1
-                    else:
-                        audio_path = os.path.join(audio_extracted_path, audio_file)
-                        yield idx, self._metadata_from_row(row_data, audio_path=audio_path)
-                        idx += 1
-
-    def _metadata_from_row(self, row, audio_path=None, audio_bytes=None):
-        """Convert metadata row to example format"""
-        # Parse labels if they're stored as strings
-        labels = row.get("labels", [])
-        if isinstance(labels, str):
-            try:
-                labels = ast.literal_eval(labels)
-            except (ValueError, SyntaxError):
-                labels = []
-        
-        # Parse species if it's stored as string
-        species = row.get("species", [])
-        if isinstance(species, str):
-            try:
-                species = ast.literal_eval(species)
-            except (ValueError, SyntaxError):
-                species = [species] if species else []
-        
-        return {
-            "audio": {"path": audio_path, "bytes": audio_bytes} if audio_bytes else audio_path,
-            "filename": row.get("filename", ""),
-            "filepath": row.get("filepath", ""),
-            "labels": labels,
-            "species": species,
-            "site_ID": row.get("site_ID", self.config.name),
-            "study_area": row.get("study_area", ""),
-            "recording_location": row.get("recording_location", ""),
-            "biome": row.get("biome", ""),
-            "latitude": str(row.get("latitude", "")),
-            "longitude": str(row.get("longitude", "")),
-            "recorder": row.get("recorder", ""),
-            "omnidirectional": row.get("omnidirectional", ""),
-            "sampling_rate": row.get("sampling_rate", ""),
-            "recording_date": str(row.get("recording_date", "")),
-            "min_annotated": int(row.get("min_annotated", 0)) if pd.notna(row.get("min_annotated")) else 0,
-            "contact": row.get("contact", ""),
-            "reference": row.get("reference", ""),
-        }
+            yield idx, { 
+                "audio": {"path": audio_url, "bytes": None},  # Let datasets handle the download
+                "labels": labels,
+                "site_ID": row.get("site_ID", self.config.name),
+                # other metadata
+            }