import h5py class MicronsReader: def __init__(self, file_path): """ Initialize the reader. Opening in read-only mode ('r') is faster and prevents accidental corruption. """ self.file_path = file_path self.f = h5py.File(self.file_path, 'r') def close(self): """Close the file handle manually.""" self.f.close() def __enter__(self): return self def __exit__(self, exc_type, exc_val, exc_tb): self.close() def get_full_data_by_hash(self, condition_hash, brain_area=None): """ Returns a dictionary with the clip and all trials (responses, behavior, pupil, times) associated with a hash. Args: condition_hash (str): The identifier for the video. brain_area (str, optional): Filter for neural responses. Returns: dict: { 'clip': np.array, 'stim_type': str, 'trials': [ {'session': str, 'trial_idx': str, 'responses': np.array, ...}, ... ] } """ # 1. Reuse get_video_data for stimulus info h_key = self._encode_hash(condition_hash) clip, stim_type = self.get_video_data(h_key) if clip is None: return None data_out = { 'clip': clip, 'stim_type': stim_type, 'trials': [] } # 2. Access instances (links to trials) video_grp = self.f[f'videos/{h_key}'] instances = video_grp['instances'] for instance_name in instances: # SoftLink to the trial group trial_grp = instances[instance_name] # Identify parent session to look up brain area indices session_key = "_".join(instance_name.split('_')[:2]) # 3. Handle Neural Responses if brain_area: area_path = f"sessions/{session_key}/meta/area_indices/{brain_area}" if area_path not in self.f: continue # Skip session if area not recorded indices = self.f[area_path][:] responses = trial_grp['responses'][indices, :] else: responses = trial_grp['responses'][:] # 4. Aggregate all datasets in the trial folder data_out['trials'].append({ 'session': session_key, 'trial_idx': trial_grp.name.split('/')[-1], 'responses': responses, 'behavior': trial_grp['behavior'][:], 'pupil_center': trial_grp['pupil_center'][:], }) return data_out def get_responses_by_hash(self, condition_hash, brain_area=None): """Retrieves only neural responses associated with a hash across sessions.""" # Note: This is now essentially a subset of get_full_data_by_hash full_data = self.get_full_data_by_hash(condition_hash, brain_area=brain_area) if full_data is None: return [] return [ { 'session': t['session'], 'trial_idx': t['trial_idx'], 'responses': t['responses'] } for t in full_data['trials'] ] def _encode_hash(self, h): """Helper to convert a real hash into an HDF5-safe key.""" return h.replace('/', '%2F') def _decode_hash(self, h): return h.replace('%2F', '/') def get_video_data(self, condition_hash): h_key = self._encode_hash(condition_hash) video_path = f"videos/{h_key}" if video_path not in self.f: return None, None vid_grp = self.f[video_path] clip = vid_grp['clip'][:] stim_type = vid_grp.attrs.get('type', 'Unknown') return clip, stim_type def get_hashes_by_session(self, session_key, return_unique=False): """Returns a unique list of condition hashes shown in a specific session.""" if session_key not in self.f['sessions']: raise ValueError(f"Session {session_key} not found.") hashes = self.f[f'sessions/{session_key}/meta/condition_hashes'][:] return set([self._decode_hash(h.decode('utf-8')) for h in hashes]) if return_unique else [self._decode_hash(h.decode('utf-8')) for h in hashes] def get_hashes_by_type(self, stim_type): """Returns hashes belonging to a specific type (e.g., 'Monet2').""" if stim_type not in self.f['types']: return [] encoded_keys = list(self.f[f'types/{stim_type}'].keys()) return [self._decode_hash(k) for k in encoded_keys] def get_available_brain_areas(self, session_key=None): """Returns a list of brain areas available in the file or a specific session.""" if session_key: return list(self.f[f'sessions/{session_key}/meta/area_indices'].keys()) return list(self.f['brain_areas'].keys()) def count_trials_per_hash(self): return {k: len(v['instances']) for k, v in self.f['videos'].items()} def print_structure(self, max_items=5, follow_links=False): """ Prints a tree-like representation of the HDF5 database. Args: max_items (int): Max children to show per group. follow_links (bool): If True, recurses into SoftLinks (original behavior). If False, prints the link destination and stops. """ print(f"\nStructure of: {self.file_path}") print("=" * 50) def _print_tree(name, obj, indent="", current_key=""): item_name = current_key if current_key else name # 1. Check if this specific key is a SoftLink # We need the parent object to check the link status of the child # For the root level, obj is self.f is_link = False link_path = "" # Dataset vs Group handling if isinstance(obj, h5py.Dataset): print(f"{indent}📄 {item_name:20} [Dataset: {obj.shape}, {obj.dtype}]") return # It's a Group attrs = dict(obj.attrs) attr_str = f" | Attributes: {attrs}" if attrs else "" print(f"{indent}📂 {item_name.upper()}/ {attr_str}") keys = sorted(obj.keys()) num_keys = len(keys) display_keys = keys[:max_items] for key in display_keys: # Check link status without dereferencing link_obj = obj.get(key, getlink=True) if isinstance(link_obj, h5py.SoftLink): # It is a SoftLink! if follow_links: _print_tree(key, obj[key], indent + " ", current_key=key) else: print(f"{indent} 🔗 {key:18} -> {link_obj.path}") else: # It is a real Group or Dataset _print_tree(key, obj[key], indent + " ", current_key=key) if num_keys > max_items: print(f"{indent} ... and {num_keys - max_items} more items") # Start recursion for key in sorted(self.f.keys()): # We treat the root level keys as 'real' objects to start _print_tree(key, self.f[key], current_key=key)