#!/usr/bin/env python3 """ Script to automatically download datasets from EMBL's BioImage Archive and extract metadata information. """ import os import re import requests import yaml from bs4 import BeautifulSoup from urllib.parse import urljoin, urlparse import time from pathlib import Path class BioImageArchiveDownloader: def __init__(self, base_data_folder=""): self.base_data_folder = Path(base_data_folder) self.base_data_folder.mkdir(exist_ok=True) self.session = requests.Session() self.session.headers.update({ 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36' }) def get_next_dataset_number(self): """Get the next available dataset number.""" existing_folders = [f for f in self.base_data_folder.iterdir() if f.is_dir() and f.name.startswith('dataset_')] if not existing_folders: return "001" numbers = [] for folder in existing_folders: match = re.match(r'dataset_(\d+)', folder.name) if match: numbers.append(int(match.group(1))) next_num = max(numbers) + 1 if numbers else 1 return f"{next_num:03d}" def extract_accession_from_url(self, url): """Extract dataset accession from URL.""" patterns = [ r'/galleries/(S-[A-Z]+[0-9]+)', r'/pages/(S-[A-Z]+[0-9]+)', ] for p in patterns: match = re.search(p, url) if match: return match.group(1) return None def parse_dataset_page(self, url): """Parse the dataset page and extract metadata.""" print(f"Fetching dataset page: {url}") response = self.session.get(url) response.raise_for_status() soup = BeautifulSoup(response.text, 'html.parser') # Extract basic study information metadata = { 'source_url': url, 'download_timestamp': time.strftime('%Y-%m-%d %H:%M:%S'), } # Find the larger representative preview image large_preview_url = self._find_large_preview_image(soup, url) if large_preview_url: metadata['large_preview_url'] = large_preview_url print(f"Found large preview image: {large_preview_url}") else: print("No large preview image found on the page") # Extract study title title_elem = soup.find('h1') if title_elem: metadata['study_title'] = title_elem.get_text(strip=True) # Extract study information section study_info = {} # Look for organism organism_elem = soup.find(string=re.compile(r'Organism', re.I)) if organism_elem: organism_value = organism_elem.find_next('div') if organism_value: study_info['organism'] = organism_value.get_text(strip=True) # Look for imaging type imaging_elem = soup.find(string=re.compile(r'Imaging type', re.I)) if imaging_elem: imaging_value = imaging_elem.find_next('div') if imaging_value: study_info['imaging_type'] = imaging_value.get_text(strip=True) # Look for license license_elem = soup.find(string=re.compile(r'License', re.I)) if license_elem: license_value = license_elem.find_next('div') if license_value: study_info['license'] = license_value.get_text(strip=True) # Look for author author_elem = soup.find(string=re.compile(r'By|Author', re.I)) if author_elem: author_value = author_elem.find_next('div') if author_value: study_info['author'] = author_value.get_text(strip=True) # Look for release date release_elem = soup.find(string=re.compile(r'Released', re.I)) if release_elem: release_value = release_elem.find_next('div') if release_value: study_info['release_date'] = release_value.get_text(strip=True) metadata['study_info'] = study_info # Extract content information content_info = {} content_elem = soup.find(string=re.compile(r'Content', re.I)) if content_elem: content_text = content_elem.get_text(strip=True) # Extract number of images images_match = re.search(r'(\d+)\s+images?', content_text) if images_match: content_info['total_images'] = int(images_match.group(1)) # Extract number of other files files_match = re.search(r'(\d+)\s+other\s+files?', content_text) if files_match: content_info['other_files'] = int(files_match.group(1)) metadata['content_info'] = content_info # Extract image information from both tables images = [] tables = soup.find_all('table') # First, parse the "Viewable images" table (has preview images) if len(tables) > 0: viewable_table = tables[0] print("Parsing viewable images table (with previews)...") rows = viewable_table.find_all('tr')[1:] # Skip header row for row in rows: cells = row.find_all('td') if len(cells) >= 6: # Image ID, Preview, Filename, Dimensions, Download Size, Actions image_info = self._parse_image_row(cells, url, has_preview=True) if image_info: images.append(image_info) # Then, try to parse the "All images" table (complete list) if len(tables) > 1: all_images_table = tables[1] print("Parsing all images table (complete list)...") rows = all_images_table.find_all('tr')[1:] # Skip header row print(f"Found {len(rows)} rows in all images table") if len(rows) == 0: print("All images table appears to be empty (likely loaded dynamically)") print("Only images with previews are available for download") else: for row in rows: cells = row.find_all('td') if len(cells) >= 4: # Image ID, Filename, Download Size, Actions image_id_text = cells[0].get_text(strip=True) # Check if we already have this image from the viewable table existing_image = next((img for img in images if img.get('image_id') == image_id_text), None) if not existing_image: # Parse this row and add it image_info = self._parse_image_row(cells, url, has_preview=False) if image_info: images.append(image_info) else: # We already have this image with preview, skip print(f"Image {image_id_text} already exists with preview, skipping from all images table") # Sort images by image_id for consistent ordering images.sort(key=lambda x: int(x.get('image_id', '0').replace('IM', '')) if x.get('image_id', '').replace('IM', '').isdigit() else 999) metadata['images'] = images print(f"Found {len(images)} images in the dataset") return metadata def _parse_image_row(self, cells, url, has_preview=False): """Parse a table row to extract image information.""" image_info = {} # Image ID (first column) image_id_text = cells[0].get_text(strip=True) if image_id_text: image_info['image_id'] = image_id_text # Filename (second column in all images table, third in viewable table) filename_col = 2 if has_preview else 1 if len(cells) > filename_col: filename_text = cells[filename_col].get_text(strip=True) if filename_text: image_info['filename'] = filename_text # Dimensions (third column in viewable table, not available in all images table) if has_preview and len(cells) > 3: dimensions_text = cells[3].get_text(strip=True) if dimensions_text and dimensions_text != 'Unavailable': # Parse dimensions like (1, 4, 3, 2160, 2160) dims_match = re.search(r'\(([^)]+)\)', dimensions_text) if dims_match: dims = [int(x.strip()) for x in dims_match.group(1).split(',')] image_info['dimensions'] = { 'T': dims[0] if len(dims) > 0 else 1, 'C': dims[1] if len(dims) > 1 else 1, 'Z': dims[2] if len(dims) > 2 else 1, 'Y': dims[3] if len(dims) > 3 else 1, 'X': dims[4] if len(dims) > 4 else 1 } # Download URL (from actions column) actions_col = 5 if has_preview else 3 if len(cells) > actions_col: actions_cell = cells[actions_col] download_links = actions_cell.find_all('a', href=True) for link in download_links: href = link.get('href') if href and ('download' in href.lower() or 'files' in href.lower()): image_info['download_url'] = href break # Preview image URL (only in viewable table) if has_preview and len(cells) > 1: preview_cell = cells[1] # Preview column preview_img = preview_cell.find('img') if preview_img: preview_src = preview_img.get('src') if preview_src: # Convert relative URL to absolute if preview_src.startswith('/'): image_info['preview_url'] = 'https://www.ebi.ac.uk' + preview_src else: image_info['preview_url'] = urljoin(url, preview_src) return image_info if image_info else None def _find_large_preview_image(self, soup, base_url): """Find the larger representative preview image on the page.""" img_tags = soup.find_all('img') print(f"Found {len(img_tags)} images on the page") # Strategy 1: Look for explicit representative images for img in img_tags: src = img.get('src', '') if not src: continue # Convert relative URL to absolute if src.startswith('/'): full_url = 'https://www.ebi.ac.uk' + src else: full_url = urljoin(base_url, src) # Look for representative images with larger dimensions # Common patterns: IM*-representative-*-*.png, *-representative-*.png, etc. if any(pattern in src.lower() for pattern in [ 'representative', 'overview', 'sample' ]): # Check if it's a larger image (not a small thumbnail) if any(size in src for size in ['512', '1024', '2048', 'large', 'big']): print(f"Found representative image: {src}") return full_url # Strategy 2: Look for images that are larger than typical thumbnails # but not necessarily labeled as "representative" large_images = [] for img in img_tags: src = img.get('src', '') if not src: continue # Convert relative URL to absolute if src.startswith('/'): full_url = 'https://www.ebi.ac.uk' + src else: full_url = urljoin(base_url, src) # Look for images that are likely larger (not thumbnails) if any(size in src for size in ['512', '1024', '2048']) and 'thumb' not in src.lower(): print(f"Found potential large image: {src}") large_images.append(full_url) # Strategy 3: If we found large images, pick the first one if large_images: return large_images[0] # Strategy 4: Look for any image that's not a thumbnail # This is a fallback for pages that might have different naming conventions for img in img_tags: src = img.get('src', '') if not src: continue # Convert relative URL to absolute if src.startswith('/'): full_url = 'https://www.ebi.ac.uk' + src else: full_url = urljoin(base_url, src) # Skip obvious thumbnails if 'thumb' in src.lower() or '128' in src: continue # Look for images that might be larger based on filename patterns if any(pattern in src.lower() for pattern in [ 'preview', 'view', 'display', 'show' ]): print(f"Found potential preview image: {src}") return full_url # Strategy 5: As a last resort, try to find the largest available image # by looking for images with dimension indicators in the filename dimension_images = [] for img in img_tags: src = img.get('src', '') if not src: continue # Convert relative URL to absolute if src.startswith('/'): full_url = 'https://www.ebi.ac.uk' + src else: full_url = urljoin(base_url, src) # Look for images with dimension patterns like 512x512, 1024x1024, etc. import re dim_match = re.search(r'(\d+)[x\-](\d+)', src) if dim_match: width, height = int(dim_match.group(1)), int(dim_match.group(2)) if width >= 256 and height >= 256: # At least 256x256 dimension_images.append((full_url, width * height)) print(f"Found dimensioned image: {src} ({width}x{height})") # Return the largest image by area if dimension_images: largest = max(dimension_images, key=lambda x: x[1]) print(f"Selected largest image: {largest[0]} (area: {largest[1]})") return largest[0] print("No suitable large preview image found") return None def _find_best_individual_preview(self, images_to_download): """Find the best individual preview image from the available images.""" if not images_to_download: return None # Look for images with preview URLs preview_candidates = [] for image_info in images_to_download: if 'preview_url' in image_info and image_info['preview_url']: preview_url = image_info['preview_url'] # Try to determine the size/quality of the preview # Look for dimension indicators in the URL import re dim_match = re.search(r'(\d+)[x\-](\d+)', preview_url) if dim_match: width, height = int(dim_match.group(1)), int(dim_match.group(2)) area = width * height preview_candidates.append((preview_url, area, image_info.get('image_id', 'Unknown'))) print(f"Found preview candidate: {image_info.get('image_id', 'Unknown')} - {width}x{height} (area: {area})") else: # If no dimensions in URL, assume it's a standard thumbnail preview_candidates.append((preview_url, 128*128, image_info.get('image_id', 'Unknown'))) print(f"Found preview candidate: {image_info.get('image_id', 'Unknown')} - standard thumbnail") if not preview_candidates: return None # Sort by area (largest first) and return the best one preview_candidates.sort(key=lambda x: x[1], reverse=True) best_url, best_area, best_id = preview_candidates[0] print(f"Selected best individual preview: {best_id} (area: {best_area})") return best_url def download_image(self, image_url, local_path): """Download a single image.""" print(f"Downloading: {image_url}") response = self.session.get(image_url, stream=True) response.raise_for_status() with open(local_path, 'wb') as f: for chunk in response.iter_content(chunk_size=8192): f.write(chunk) print(f"Downloaded: {local_path}") return local_path def download_dataset(self, dataset_url, image_id=None, download_files=True): """Download a complete dataset from BioImage Archive.""" # Get next dataset number dataset_num = self.get_next_dataset_number() dataset_folder = self.base_data_folder / f"dataset_{dataset_num}" dataset_folder.mkdir(exist_ok=True) print(f"Creating dataset folder: {dataset_folder}") # Extract accession accession = self.extract_accession_from_url(dataset_url) if not accession: raise ValueError("Could not extract accession from URL") # Parse dataset page metadata = self.parse_dataset_page(dataset_url) metadata['accession'] = accession metadata['dataset_number'] = dataset_num metadata['download_files'] = download_files # Download images (if requested) downloaded_files = [] images_to_download = metadata['images'] # Filter by image_id if provided if image_id: images_to_download = [img for img in images_to_download if img.get('image_id') == image_id] if not images_to_download: available_ids = [img.get('image_id') for img in metadata['images']] print(f"Available Image IDs: {available_ids}") print("Note: Only images with preview thumbnails are available for download.") print("The full list of 1170 images is loaded dynamically and not accessible via simple HTTP requests.") raise ValueError(f"Image ID '{image_id}' not found. Available IDs: {available_ids}") print(f"Filtering to Image ID: {image_id}") else: # If no image_id specified, download first image images_to_download = images_to_download[:1] print("No Image ID specified, downloading first image") # Download preview images - prioritize large representative, fall back to best individual preview preview_files = [] preview_downloaded = False if 'large_preview_url' in metadata and metadata['large_preview_url']: # Use the large preview image for all images in the dataset large_preview_filename = "dataset_preview.png" large_preview_path = dataset_folder / large_preview_filename try: print(f"Downloading large representative preview image...") self.download_image(metadata['large_preview_url'], large_preview_path) preview_files.append({ 'filename': large_preview_filename, 'local_path': str(large_preview_path), 'image_id': 'representative', 'preview_url': metadata['large_preview_url'], 'type': 'large_representative' }) print(f"Successfully downloaded large preview: {large_preview_filename}") preview_downloaded = True except Exception as e: print(f"Failed to download large preview image: {e}") # If no large representative image was found or downloaded, try to find the best individual preview if not preview_downloaded: best_preview_url = self._find_best_individual_preview(images_to_download) if best_preview_url: preview_filename = "dataset_preview.png" preview_path = dataset_folder / preview_filename try: print(f"Downloading best available individual preview image...") self.download_image(best_preview_url, preview_path) preview_files.append({ 'filename': preview_filename, 'local_path': str(preview_path), 'image_id': 'best_available', 'preview_url': best_preview_url, 'type': 'best_individual' }) print(f"Successfully downloaded best preview: {preview_filename}") preview_downloaded = True except Exception as e: print(f"Failed to download best individual preview: {e}") if not preview_downloaded: print("No suitable preview image found, skipping preview download") if download_files: print("Downloading image files...") for i, image_info in enumerate(images_to_download): if 'download_url' in image_info: filename = image_info['filename'] local_path = dataset_folder / filename # Create directory structure if needed local_path.parent.mkdir(parents=True, exist_ok=True) try: self.download_image(image_info['download_url'], local_path) downloaded_files.append({ 'filename': filename, 'local_path': str(local_path), 'image_info': image_info }) except Exception as e: print(f"Failed to download {filename}: {e}") else: print("Skipping file downloads - metadata only mode") # Still track which files would be downloaded for i, image_info in enumerate(images_to_download): if 'download_url' in image_info: downloaded_files.append({ 'filename': image_info['filename'], 'local_path': 'not_downloaded', 'image_info': image_info }) metadata['downloaded_files'] = downloaded_files metadata['preview_files'] = preview_files # Save metadata metadata_file = dataset_folder / f"dataset_{dataset_num}.yaml" with open(metadata_file, 'w', encoding='utf-8') as f: yaml.dump(metadata, f, default_flow_style=False, allow_unicode=True) print(f"Metadata saved to: {metadata_file}") print(f"Dataset {dataset_num} completed successfully!") return dataset_folder, metadata_file def list_available_images(self, dataset_url): """List all available image IDs for a dataset.""" print(f"Fetching available images from: {dataset_url}") metadata = self.parse_dataset_page(dataset_url) print(f"\nAvailable Image IDs for {metadata.get('accession', 'Unknown')}:") print("-" * 50) for i, image in enumerate(metadata['images'], 1): image_id = image.get('image_id', 'Unknown') filename = image.get('filename', 'Unknown') dimensions = image.get('dimensions', {}) print(f"{i:2d}. {image_id:8s} - {filename}") if dimensions: dims_str = f"({dimensions.get('T', 1)}, {dimensions.get('C', 1)}, {dimensions.get('Z', 1)}, {dimensions.get('Y', 1)}, {dimensions.get('X', 1)})" print(f" Dimensions: {dims_str}") return [img.get('image_id') for img in metadata['images']] def anonymize_dataset(self, dataset_folder, metadata_file): """Anonymize the dataset by renaming folders and files to generic names within the same folder.""" print(f"Anonymizing dataset: {dataset_folder}") # Get the dataset number from the folder name dataset_num = dataset_folder.name.split('_')[1] # Extract number from "dataset_001" # Track renamed files anonymized_files = [] # Process downloaded files - rename them within the same dataset folder for item in dataset_folder.rglob('*'): if item.is_file() and item.name != f"dataset_{dataset_num}.yaml": # Get relative path from original dataset folder rel_path = item.relative_to(dataset_folder) # Create anonymized filename if rel_path.parent == Path('.'): # File is in root of dataset folder anonymized_filename = f"dataset_{dataset_num}{item.suffix}" else: # File is in subfolder - flatten to root with dataset number anonymized_filename = f"dataset_{dataset_num}{item.suffix}" # Create new path within the same dataset folder anonymized_path = dataset_folder / anonymized_filename # Move (rename) the file within the same folder item.rename(anonymized_path) anonymized_files.append({ 'original_path': str(rel_path), 'anonymized_path': str(anonymized_path.relative_to(self.base_data_folder)), 'anonymized_filename': anonymized_filename }) print(f"Renamed: {rel_path} -> {anonymized_filename}") # Remove empty subfolders after renaming files for item in dataset_folder.rglob('*'): if item.is_dir() and item != dataset_folder: # Check if directory is empty try: if not any(item.iterdir()): # Directory is empty item.rmdir() print(f"Removed empty folder: {item.relative_to(dataset_folder)}") except OSError: # Directory not empty or other error, skip pass # Update metadata with anonymization info with open(metadata_file, 'r', encoding='utf-8') as f: metadata = yaml.safe_load(f) metadata['anonymized'] = True metadata['anonymized_files'] = anonymized_files metadata['original_dataset_folder'] = str(dataset_folder.relative_to(self.base_data_folder)) metadata['anonymized_dataset_folder'] = str(dataset_folder.relative_to(self.base_data_folder)) # Save updated metadata with open(metadata_file, 'w', encoding='utf-8') as f: yaml.dump(metadata, f, default_flow_style=False, allow_unicode=True) print(f"Anonymized dataset: {dataset_folder}") print(f"Anonymized metadata: {metadata_file}") return dataset_folder, metadata_file def main(): """Main function to test the downloader.""" downloader = BioImageArchiveDownloader() # dataset_001: S-BIAD7 test_url_1 = "https://www.ebi.ac.uk/bioimage-archive/galleries/S-BIAD7.html" # dataset_002: S-BIAD573 test_url_2 = "https://uk1s3.embassy.ebi.ac.uk/bia-integrator-data/pages/S-BIAD573.html" try: # Download dataset 1 dataset_folder, metadata_file = downloader.download_dataset( test_url_1, image_id="IM1", # Specify which image to download download_files=True ) print(f"\nSuccess! Dataset processed: {dataset_folder}") print(f"Metadata saved to: {metadata_file}") # Anonymize the dataset print("\n" + "="*50) print("ANONYMIZING DATASET") print("="*50) anonymized_folder, anonymized_metadata = downloader.anonymize_dataset(dataset_folder, metadata_file) print(f"\nAnonymized dataset: {anonymized_folder}") print(f"Anonymized metadata: {anonymized_metadata}") except Exception as e: print(f"Error processing dataset 1: {e}") # Download dataset 2 try: dataset_folder, metadata_file = downloader.download_dataset( test_url_2, image_id="IM1", # Specify which image to download download_files=True ) print(f"\nSuccess! Dataset processed: {dataset_folder}") print(f"Metadata saved to: {metadata_file}") # Anonymize the dataset print("\n" + "="*50) print("ANONYMIZING DATASET") print("="*50) anonymized_folder, anonymized_metadata = downloader.anonymize_dataset(dataset_folder, metadata_file) print(f"\nAnonymized dataset: {anonymized_folder}") print(f"Anonymized metadata: {anonymized_metadata}") except Exception as e: print(f"Error processing dataset 2: {e}") if __name__ == "__main__": main()