diff --git a/CHANGELOG.md b/CHANGELOG.md index 5288a5ca5..6952f7e71 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,7 @@ ### Deprecations * Deprecated `WaveformExtractor` usage. [PR #821](https://github.com/catalystneuro/neuroconv/pull/821) +* Changed the spikeinterface.tool functions (e.g. `add_recording`, `add_sorting`) to have `_to_nwbfile` as suffix [PR #1015](https://github.com/catalystneuro/neuroconv/pull/1015) * Deprecated use of `compression` and `compression_options` in `VideoInterface` [PR #1005](https://github.com/catalystneuro/neuroconv/pull/1005) * `get_schema_from_method_signature` has been deprecated; please use `get_json_schema_from_method_signature` instead. [PR #1016](https://github.com/catalystneuro/neuroconv/pull/1016) diff --git a/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py b/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py index 8d2df3a0c..b21210d77 100644 --- a/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py +++ b/src/neuroconv/datainterfaces/ecephys/baserecordingextractorinterface.py @@ -349,7 +349,7 @@ def add_to_nwbfile( Dictionary of keyword arguments to be passed directly to tqdm. See https://github.com/tqdm/tqdm#parameters for options. """ - from ...tools.spikeinterface import add_recording + from ...tools.spikeinterface import add_recording_to_nwbfile if stub_test or self.subset_channels is not None: recording = self.subset_recording(stub_test=stub_test) @@ -359,7 +359,7 @@ def add_to_nwbfile( if metadata is None: metadata = self.get_metadata() - add_recording( + add_recording_to_nwbfile( recording=recording, nwbfile=nwbfile, metadata=metadata, diff --git a/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py b/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py index e324b83ef..9c3c06849 100644 --- a/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py +++ b/src/neuroconv/datainterfaces/ecephys/basesortingextractorinterface.py @@ -263,17 +263,17 @@ def add_channel_metadata_to_nwb(self, nwbfile: NWBFile, metadata: Optional[DeepD This function adds metadata to the `nwbfile` in-place, meaning the `nwbfile` object is modified directly. """ from ...tools.spikeinterface import ( - add_devices, - add_electrode_groups, - add_electrodes, + add_devices_to_nwbfile, + add_electrode_groups_to_nwbfile, + add_electrodes_to_nwbfile, ) if hasattr(self, "generate_recording_with_channel_metadata"): recording = self.generate_recording_with_channel_metadata() - add_devices(nwbfile=nwbfile, metadata=metadata) - add_electrode_groups(recording=recording, nwbfile=nwbfile, metadata=metadata) - add_electrodes(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_devices_to_nwbfile(nwbfile=nwbfile, metadata=metadata) + add_electrode_groups_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_electrodes_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) def add_to_nwbfile( self, @@ -309,7 +309,7 @@ def add_to_nwbfile( The name of the units table. If write_as=='units', then units_name must also be 'units'. units_description : str, default: 'Autogenerated by neuroconv.' """ - from ...tools.spikeinterface import add_sorting + from ...tools.spikeinterface import add_sorting_to_nwbfile metadata_copy = deepcopy(metadata) if write_ecephys_metadata: @@ -335,7 +335,7 @@ def add_to_nwbfile( value=value, ) - add_sorting( + add_sorting_to_nwbfile( sorting_extractor, nwbfile=nwbfile, property_descriptions=property_descriptions, diff --git a/src/neuroconv/tools/spikeinterface/__init__.py b/src/neuroconv/tools/spikeinterface/__init__.py index 165b76fc8..cb84489f4 100644 --- a/src/neuroconv/tools/spikeinterface/__init__.py +++ b/src/neuroconv/tools/spikeinterface/__init__.py @@ -7,11 +7,21 @@ add_sorting, add_units_table, add_sorting_analyzer, - check_if_recording_traces_fit_into_memory, - get_nwb_metadata, write_recording, write_sorting, write_sorting_analyzer, add_waveforms, write_waveforms, + add_devices_to_nwbfile, + add_electrical_series_to_nwbfile, + add_electrode_groups_to_nwbfile, + add_electrodes_to_nwbfile, + add_recording_to_nwbfile, + add_sorting_to_nwbfile, + add_units_table_to_nwbfile, + add_sorting_analyzer_to_nwbfile, + write_recording_to_nwbfile, + write_sorting_to_nwbfile, + write_sorting_analyzer_to_nwbfile, + check_if_recording_traces_fit_into_memory, ) diff --git a/src/neuroconv/tools/spikeinterface/spikeinterface.py b/src/neuroconv/tools/spikeinterface/spikeinterface.py index 3b05f5fa0..48a102bc5 100644 --- a/src/neuroconv/tools/spikeinterface/spikeinterface.py +++ b/src/neuroconv/tools/spikeinterface/spikeinterface.py @@ -22,7 +22,7 @@ from ...utils.str_utils import human_readable_size -def get_nwb_metadata(recording: BaseRecording, metadata: dict = None): +def _get_nwb_metadata(recording: BaseRecording, metadata: dict = None): """ Return default metadata for all recording fields. @@ -49,6 +49,19 @@ def get_nwb_metadata(recording: BaseRecording, metadata: dict = None): def add_devices(nwbfile: pynwb.NWBFile, metadata: Optional[DeepDict] = None): + """ + Deprecated function. Use add_devices_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_devices' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_devices_to_nwbfile' instead.", + ) + + return add_devices_to_nwbfile(nwbfile=nwbfile, metadata=metadata) + + +def add_devices_to_nwbfile(nwbfile: pynwb.NWBFile, metadata: Optional[DeepDict] = None): """ Add device information to nwbfile object. @@ -84,12 +97,25 @@ def add_devices(nwbfile: pynwb.NWBFile, metadata: Optional[DeepDict] = None): metadata["Ecephys"] = dict() if "Device" not in metadata["Ecephys"]: metadata["Ecephys"]["Device"] = [defaults] - for dev in metadata["Ecephys"]["Device"]: - if dev.get("name", defaults["name"]) not in nwbfile.devices: - nwbfile.create_device(**dict(defaults, **dev)) + for device_metadata in metadata["Ecephys"]["Device"]: + if device_metadata.get("name", defaults["name"]) not in nwbfile.devices: + nwbfile.create_device(**dict(defaults, **device_metadata)) def add_electrode_groups(recording: BaseRecording, nwbfile: pynwb.NWBFile, metadata: dict = None): + """ + Deprecated function. Use add_electrode_groups_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_electrode_groups' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_electrode_groups_to_nwbfile' instead.", + ) + + return add_electrode_groups_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) + + +def add_electrode_groups_to_nwbfile(recording: BaseRecording, nwbfile: pynwb.NWBFile, metadata: Optional[dict] = None): """ Add electrode group information to nwbfile object. @@ -120,18 +146,15 @@ def add_electrode_groups(recording: BaseRecording, nwbfile: pynwb.NWBFile, metad but will only use default description and location. """ assert isinstance(nwbfile, pynwb.NWBFile), "'nwbfile' should be of type pynwb.NWBFile" - if len(nwbfile.devices) == 0: - warnings.warn("When adding ElectrodeGroup, no Devices were found on nwbfile. Creating a Device now...") - add_devices(nwbfile=nwbfile, metadata=metadata) + if metadata is None: metadata = dict() if "Ecephys" not in metadata: metadata["Ecephys"] = dict() - if "group_name" in recording.get_property_keys(): - group_names = np.unique(recording.get_property("group_name")) - else: - group_names = np.unique(recording.get_channel_groups()).astype("str", copy=False) + add_devices_to_nwbfile(nwbfile=nwbfile, metadata=metadata) + + group_names = _get_group_name(recording=recording) defaults = [ dict( @@ -149,9 +172,9 @@ def add_electrode_groups(recording: BaseRecording, nwbfile: pynwb.NWBFile, metad [isinstance(x, dict) for x in metadata["Ecephys"]["ElectrodeGroup"]] ), "Expected metadata['Ecephys']['ElectrodeGroup'] to be a list of dictionaries!" - for grp in metadata["Ecephys"]["ElectrodeGroup"]: - if grp.get("name", defaults[0]["name"]) not in nwbfile.electrode_groups: - device_name = grp.get("device", defaults[0]["device"]) + for group_metadata in metadata["Ecephys"]["ElectrodeGroup"]: + if group_metadata.get("name", defaults[0]["name"]) not in nwbfile.electrode_groups: + device_name = group_metadata.get("device", defaults[0]["device"]) if device_name not in nwbfile.devices: new_device_metadata = dict(Ecephys=dict(Device=[dict(name=device_name)])) add_devices(nwbfile=nwbfile, metadata=new_device_metadata) @@ -159,9 +182,11 @@ def add_electrode_groups(recording: BaseRecording, nwbfile: pynwb.NWBFile, metad f"Device '{device_name}' not detected in " "attempted link to electrode group! Automatically generating." ) - electrode_group_kwargs = dict(defaults[0], **grp) + electrode_group_kwargs = dict(defaults[0], **group_metadata) electrode_group_kwargs.update(device=nwbfile.devices[device_name]) nwbfile.create_electrode_group(**electrode_group_kwargs) + + # TODO: Check this, probably not necessary if not nwbfile.electrode_groups: device_name = list(nwbfile.devices.keys())[0] device = nwbfile.devices[device_name] @@ -365,7 +390,32 @@ def add_electrodes( null_values_for_properties: Optional[dict] = None, ): """ - Add channels from recording object as electrodes to nwbfile object. + Deprecated function. Use add_electrodes_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_electrodes' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_electrodes_to_nwbfile' instead.", + ) + + return add_electrodes_to_nwbfile( + recording=recording, + nwbfile=nwbfile, + metadata=metadata, + exclude=exclude, + null_values_for_properties=null_values_for_properties, + ) + + +def add_electrodes_to_nwbfile( + recording: BaseRecording, + nwbfile: pynwb.NWBFile, + metadata: Optional[dict] = None, + exclude: tuple = (), + null_values_for_properties: Optional[dict] = None, +): + """ + Build an electrode_table from the recording information and it to the nwbfile object. Parameters ---------- @@ -431,7 +481,7 @@ def add_electrodes( data_to_add = dict() recording_properties = recording.get_property_keys() - special_cases = [ + spikeinterface_special_cases = [ "offset_to_uV", # Written in the ElectricalSeries "gain_to_uV", # Written in the ElectricalSeries "contact_vector", # Structured array representing the probe @@ -440,7 +490,7 @@ def add_electrodes( "group_name", # We handle this here _get_group_name "group", # We handle this here with _get_group_name ] - excluded_properties = list(exclude) + special_cases + excluded_properties = list(exclude) + spikeinterface_special_cases properties_to_extract = [property for property in recording_properties if property not in excluded_properties] for property in properties_to_extract: @@ -485,7 +535,7 @@ def add_electrodes( if len(groupless_names) > 0: electrode_group_list = [dict(name=group_name) for group_name in groupless_names] missing_group_metadata = dict(Ecephys=dict(ElectrodeGroup=electrode_group_list)) - add_electrode_groups(recording=recording, nwbfile=nwbfile, metadata=missing_group_metadata) + add_electrode_groups_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=missing_group_metadata) group_list = [nwbfile.electrode_groups[group_name] for group_name in group_names] data_to_add["group"] = dict(description="the ElectrodeGroup object", data=group_list, index=False) @@ -617,7 +667,7 @@ def _recording_traces_to_hdmf_iterator( recording: BaseRecording, segment_index: int = None, return_scaled: bool = False, - iterator_type: str = "v2", + iterator_type: Optional[str] = "v2", iterator_opts: dict = None, ) -> AbstractDataChunkIterator: """Function to wrap traces of spikeinterface recording into an AbstractDataChunkIterator. @@ -702,6 +752,45 @@ def add_electrical_series( compression_opts: Optional[int] = None, iterator_type: Optional[str] = "v2", iterator_opts: Optional[dict] = None, +): + """ + Deprecated function. Use add_electrical_series_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_electrical_series' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_electrical_series_to_nwbfile' instead.", + ) + + return add_electrical_series_to_nwbfile( + recording=recording, + nwbfile=nwbfile, + metadata=metadata, + segment_index=segment_index, + starting_time=starting_time, + write_as=write_as, + es_key=es_key, + write_scaled=write_scaled, + compression=compression, + compression_opts=compression_opts, + iterator_type=iterator_type, + iterator_opts=iterator_opts, + ) + + +def add_electrical_series_to_nwbfile( + recording: BaseRecording, + nwbfile: pynwb.NWBFile, + metadata: dict = None, + segment_index: int = 0, + starting_time: Optional[float] = None, + write_as: Literal["raw", "processed", "lfp"] = "raw", + es_key: str = None, + write_scaled: bool = False, + compression: Optional[str] = None, + compression_opts: Optional[int] = None, + iterator_type: Optional[str] = "v2", + iterator_opts: Optional[dict] = None, ): """ Adds traces from recording object as ElectricalSeries to an NWBFile object. @@ -797,7 +886,7 @@ def add_electrical_series( eseries_kwargs["name"] += f"{segment_index:0{width}}" # The add_electrodes adds a column with channel name to the electrode table. - add_electrodes(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_electrodes_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) # Create a region for the electrodes table electrode_table_indices = _get_electrode_table_indices_for_recording(recording=recording, nwbfile=nwbfile) @@ -869,7 +958,7 @@ def add_electrical_series( ecephys_mod.data_interfaces["LFP"].add_electrical_series(es) -def add_electrodes_info(recording: BaseRecording, nwbfile: pynwb.NWBFile, metadata: dict = None): +def add_electrodes_info_to_nwbfile(recording: BaseRecording, nwbfile: pynwb.NWBFile, metadata: dict = None): """ Add device, electrode_groups, and electrodes info to the nwbfile. @@ -902,9 +991,9 @@ def add_electrodes_info(recording: BaseRecording, nwbfile: pynwb.NWBFile, metada If no group information is passed via metadata, automatic linking to existing electrode groups, possibly including the default, will occur. """ - add_devices(nwbfile=nwbfile, metadata=metadata) - add_electrode_groups(recording=recording, nwbfile=nwbfile, metadata=metadata) - add_electrodes(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_devices_to_nwbfile(nwbfile=nwbfile, metadata=metadata) + add_electrode_groups_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_electrodes_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) def add_recording( @@ -920,6 +1009,45 @@ def add_recording( compression_opts: Optional[int] = None, iterator_type: str = "v2", iterator_opts: Optional[dict] = None, +): + """ + Deprecated function. Use add_recording_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_recording' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_recording_to_nwbfile' instead.", + ) + + return add_recording_to_nwbfile( + recording=recording, + nwbfile=nwbfile, + metadata=metadata, + starting_time=starting_time, + write_as=write_as, + es_key=es_key, + write_electrical_series=write_electrical_series, + write_scaled=write_scaled, + compression=compression, + compression_opts=compression_opts, + iterator_type=iterator_type, + iterator_opts=iterator_opts, + ) + + +def add_recording_to_nwbfile( + recording: BaseRecording, + nwbfile: pynwb.NWBFile, + metadata: Optional[dict] = None, + starting_time: Optional[float] = None, + write_as: Literal["raw", "processed", "lfp"] = "raw", + es_key: Optional[str] = None, + write_electrical_series: bool = True, + write_scaled: bool = False, + compression: Optional[str] = "gzip", + compression_opts: Optional[int] = None, + iterator_type: str = "v2", + iterator_opts: Optional[dict] = None, ): """ Add traces from a recording object as an ElectricalSeries to an NWBFile object. @@ -977,15 +1105,14 @@ def add_recording( if hasattr(recording, "nwb_metadata"): metadata = dict_deep_update(recording.nwb_metadata, metadata) elif metadata is None: - metadata = get_nwb_metadata(recording=recording) + metadata = _get_nwb_metadata(recording=recording) - # Convenience function to add device, electrode groups and electrodes info - add_electrodes_info(recording=recording, nwbfile=nwbfile, metadata=metadata) + add_electrodes_info_to_nwbfile(recording=recording, nwbfile=nwbfile, metadata=metadata) if write_electrical_series: number_of_segments = recording.get_num_segments() for segment_index in range(number_of_segments): - add_electrical_series( + add_electrical_series_to_nwbfile( recording=recording, nwbfile=nwbfile, segment_index=segment_index, @@ -1017,6 +1144,51 @@ def write_recording( compression_opts: Optional[int] = None, iterator_type: Optional[str] = "v2", iterator_opts: Optional[dict] = None, +): + """ + Deprecated function. Use write_recording_to_nwbfile instead. + """ + + warnings.warn( + "The 'write_recording' function is deprecated and will be removed after February 2025. \n" + "Please use 'write_recording_to_nwbfile' instead.", + ) + + return write_recording_to_nwbfile( + recording=recording, + nwbfile_path=nwbfile_path, + nwbfile=nwbfile, + metadata=metadata, + overwrite=overwrite, + verbose=verbose, + starting_time=starting_time, + write_as=write_as, + es_key=es_key, + write_electrical_series=write_electrical_series, + write_scaled=write_scaled, + compression=compression, + compression_opts=compression_opts, + iterator_type=iterator_type, + iterator_opts=iterator_opts, + ) + + +def write_recording_to_nwbfile( + recording: BaseRecording, + nwbfile_path: Optional[FilePathType] = None, + nwbfile: Optional[pynwb.NWBFile] = None, + metadata: Optional[dict] = None, + overwrite: bool = False, + verbose: bool = True, + starting_time: Optional[float] = None, + write_as: Optional[str] = "raw", + es_key: Optional[str] = None, + write_electrical_series: bool = True, + write_scaled: bool = False, + compression: Optional[str] = "gzip", + compression_opts: Optional[int] = None, + iterator_type: Optional[str] = "v2", + iterator_opts: Optional[dict] = None, ) -> pynwb.NWBFile: """ Primary method for writing a RecordingExtractor object to an NWBFile. @@ -1124,7 +1296,7 @@ def write_recording( with make_or_load_nwbfile( nwbfile_path=nwbfile_path, nwbfile=nwbfile, metadata=metadata, overwrite=overwrite, verbose=verbose ) as nwbfile_out: - add_recording( + add_recording_to_nwbfile( recording=recording, nwbfile=nwbfile_out, starting_time=starting_time, @@ -1154,6 +1326,45 @@ def add_units_table( waveform_sds: Optional[np.ndarray] = None, unit_electrode_indices=None, null_values_for_properties: Optional[dict] = None, +): + """ + Deprecated function. Use add_units_table_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_units_table' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_units_table_to_nwbfile' instead.", + ) + + return add_units_table_to_nwbfile( + sorting=sorting, + nwbfile=nwbfile, + unit_ids=unit_ids, + property_descriptions=property_descriptions, + skip_properties=skip_properties, + units_table_name=units_table_name, + unit_table_description=unit_table_description, + write_in_processing_module=write_in_processing_module, + waveform_means=waveform_means, + waveform_sds=waveform_sds, + unit_electrode_indices=unit_electrode_indices, + null_values_for_properties=null_values_for_properties, + ) + + +def add_units_table_to_nwbfile( + sorting: BaseSorting, + nwbfile: pynwb.NWBFile, + unit_ids: Optional[List[Union[str, int]]] = None, + property_descriptions: Optional[dict] = None, + skip_properties: Optional[List[str]] = None, + units_table_name: str = "units", + unit_table_description: Optional[str] = None, + write_in_processing_module: bool = False, + waveform_means: Optional[np.ndarray] = None, + waveform_sds: Optional[np.ndarray] = None, + unit_electrode_indices=None, + null_values_for_properties: Optional[dict] = None, ): """ Add sorting data to a NWBFile object as a Units table. @@ -1192,6 +1403,7 @@ def add_units_table( null_values_for_properties: dict, optional A dictionary mapping properties to null values to use when the property is not present """ + unit_table_description = unit_table_description or "Autogenerated by neuroconv." assert isinstance( nwbfile, pynwb.NWBFile @@ -1412,6 +1624,45 @@ def add_sorting( waveform_means: Optional[np.ndarray] = None, waveform_sds: Optional[np.ndarray] = None, unit_electrode_indices=None, +): + """ + Deprecated function. Use add_sorting_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_sorting' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_sorting_to_nwbfile' instead.", + ) + + return add_sorting_to_nwbfile( + sorting=sorting, + nwbfile=nwbfile, + unit_ids=unit_ids, + property_descriptions=property_descriptions, + skip_properties=skip_properties, + skip_features=skip_features, + write_as=write_as, + units_name=units_name, + units_description=units_description, + waveform_means=waveform_means, + waveform_sds=waveform_sds, + unit_electrode_indices=unit_electrode_indices, + ) + + +def add_sorting_to_nwbfile( + sorting: BaseSorting, + nwbfile: Optional[pynwb.NWBFile] = None, + unit_ids: Optional[Union[List[str], List[int]]] = None, + property_descriptions: Optional[dict] = None, + skip_properties: Optional[List[str]] = None, + skip_features: Optional[List[str]] = None, + write_as: Literal["units", "processing"] = "units", + units_name: str = "units", + units_description: str = "Autogenerated by neuroconv.", + waveform_means: Optional[np.ndarray] = None, + waveform_sds: Optional[np.ndarray] = None, + unit_electrode_indices=None, ): """Add sorting data (units and their properties) to an NWBFile. @@ -1462,7 +1713,7 @@ def add_sorting( ], f"Argument write_as ({write_as}) should be one of 'units' or 'processing'!" write_in_processing_module = False if write_as == "units" else True - add_units_table( + add_units_table_to_nwbfile( sorting=sorting, unit_ids=unit_ids, nwbfile=nwbfile, @@ -1494,6 +1745,53 @@ def write_sorting( waveform_means: Optional[np.ndarray] = None, waveform_sds: Optional[np.ndarray] = None, unit_electrode_indices=None, +): + """ + Deprecated function. Use write_sorting_to_nwbfile instead. + """ + + warnings.warn( + "The 'write_sorting' function is deprecated and will be removed after February 2025. \n" + "Please use 'write_sorting_to_nwbfile' instead.", + ) + + return write_sorting_to_nwbfile( + sorting=sorting, + nwbfile_path=nwbfile_path, + nwbfile=nwbfile, + metadata=metadata, + overwrite=overwrite, + verbose=verbose, + unit_ids=unit_ids, + property_descriptions=property_descriptions, + skip_properties=skip_properties, + skip_features=skip_features, + write_as=write_as, + units_name=units_name, + units_description=units_description, + waveform_means=waveform_means, + waveform_sds=waveform_sds, + unit_electrode_indices=unit_electrode_indices, + ) + + +def write_sorting_to_nwbfile( + sorting: BaseSorting, + nwbfile_path: Optional[FilePathType] = None, + nwbfile: Optional[pynwb.NWBFile] = None, + metadata: Optional[dict] = None, + overwrite: bool = False, + verbose: bool = True, + unit_ids: Optional[List[Union[str, int]]] = None, + property_descriptions: Optional[dict] = None, + skip_properties: Optional[List[str]] = None, + skip_features: Optional[List[str]] = None, + write_as: Literal["units", "processing"] = "units", + units_name: str = "units", + units_description: str = "Autogenerated by neuroconv.", + waveform_means: Optional[np.ndarray] = None, + waveform_sds: Optional[np.ndarray] = None, + unit_electrode_indices=None, ): """ Primary method for writing a SortingExtractor object to an NWBFile. @@ -1576,6 +1874,41 @@ def add_sorting_analyzer( write_as: Literal["units", "processing"] = "units", units_name: str = "units", units_description: str = "Autogenerated by neuroconv.", +): + """ + Deprecated function. Use add_sorting_analyzer_to_nwbfile instead. + """ + + warnings.warn( + "The 'add_sorting_analyzer' function is deprecated and will be removed after February 2025. \n" + "Please use 'add_sorting_analyzer_to_nwbfile' instead.", + ) + + return add_sorting_analyzer_to_nwbfile( + sorting_analyzer=sorting_analyzer, + nwbfile=nwbfile, + metadata=metadata, + recording=recording, + unit_ids=unit_ids, + skip_properties=skip_properties, + property_descriptions=property_descriptions, + write_as=write_as, + units_name=units_name, + units_description=units_description, + ) + + +def add_sorting_analyzer_to_nwbfile( + sorting_analyzer: SortingAnalyzer, + nwbfile: Optional[pynwb.NWBFile] = None, + metadata: Optional[dict] = None, + recording: Optional[BaseRecording] = None, + unit_ids: Optional[Union[List[str], List[int]]] = None, + skip_properties: Optional[List[str]] = None, + property_descriptions: Optional[dict] = None, + write_as: Literal["units", "processing"] = "units", + units_name: str = "units", + units_description: str = "Autogenerated by neuroconv.", ): """ Convenience function to write directly a sorting analyzer object to an nwbfile. @@ -1657,11 +1990,11 @@ def add_sorting_analyzer( if prop not in sorting_copy.get_property_keys(): sorting_copy.set_property(prop, tm[prop]) - add_electrodes_info(recording, nwbfile=nwbfile, metadata=metadata) + add_electrodes_info_to_nwbfile(recording, nwbfile=nwbfile, metadata=metadata) electrode_group_indices = get_electrode_group_indices(recording, nwbfile=nwbfile) unit_electrode_indices = [electrode_group_indices] * len(sorting.unit_ids) - add_units_table( + add_units_table_to_nwbfile( sorting=sorting_copy, nwbfile=nwbfile, unit_ids=unit_ids, @@ -1692,6 +2025,51 @@ def write_sorting_analyzer( write_as: Literal["units", "processing"] = "units", units_name: str = "units", units_description: str = "Autogenerated by neuroconv.", +): + """ + Deprecated function. Use write_sorting_analyzer_to_nwbfile instead. + """ + + warnings.warn( + "The 'write_sorting_analyzer' function is deprecated and will be removed after February 2025. \n" + "Please use 'write_sorting_analyzer_to_nwbfile' instead.", + ) + + return write_sorting_analyzer_to_nwbfile( + sorting_analyzer=sorting_analyzer, + nwbfile_path=nwbfile_path, + nwbfile=nwbfile, + metadata=metadata, + overwrite=overwrite, + recording=recording, + verbose=verbose, + unit_ids=unit_ids, + write_electrical_series=write_electrical_series, + add_electrical_series_kwargs=add_electrical_series_kwargs, + skip_properties=skip_properties, + property_descriptions=property_descriptions, + write_as=write_as, + units_name=units_name, + units_description=units_description, + ) + + +def write_sorting_analyzer_to_nwbfile( + sorting_analyzer: SortingAnalyzer, + nwbfile_path: Optional[FilePathType] = None, + nwbfile: Optional[pynwb.NWBFile] = None, + metadata: Optional[dict] = None, + overwrite: bool = False, + recording: Optional[BaseRecording] = None, + verbose: bool = True, + unit_ids: Optional[Union[List[str], List[int]]] = None, + write_electrical_series: bool = False, + add_electrical_series_kwargs: Optional[dict] = None, + skip_properties: Optional[List[str]] = None, + property_descriptions: Optional[dict] = None, + write_as: Literal["units", "processing"] = "units", + units_name: str = "units", + units_description: str = "Autogenerated by neuroconv.", ): """ Convenience function to write directly a sorting analyzer object to an nwbfile. @@ -1764,11 +2142,11 @@ def write_sorting_analyzer( if write_electrical_series: add_electrical_series_kwargs = add_electrical_series_kwargs or dict() - add_electrical_series( + add_electrical_series_to_nwbfile( recording=recording, nwbfile=nwbfile_out, metadata=metadata, **add_electrical_series_kwargs ) - add_sorting_analyzer( + add_sorting_analyzer_to_nwbfile( sorting_analyzer=sorting_analyzer, nwbfile=nwbfile_out, metadata=metadata, diff --git a/tests/test_ecephys/test_tools_spikeinterface.py b/tests/test_ecephys/test_tools_spikeinterface.py index ec3702fcd..cf25bab0c 100644 --- a/tests/test_ecephys/test_tools_spikeinterface.py +++ b/tests/test_ecephys/test_tools_spikeinterface.py @@ -20,12 +20,12 @@ from neuroconv.tools.nwb_helpers import get_module from neuroconv.tools.spikeinterface import ( - add_electrical_series, - add_electrodes, - add_units_table, + add_electrical_series_to_nwbfile, + add_electrodes_to_nwbfile, + add_units_table_to_nwbfile, check_if_recording_traces_fit_into_memory, - write_recording, - write_sorting_analyzer, + write_recording_to_nwbfile, + write_sorting_analyzer_to_nwbfile, ) from neuroconv.tools.spikeinterface.spikeinterfacerecordingdatachunkiterator import ( SpikeInterfaceRecordingDataChunkIterator, @@ -52,7 +52,9 @@ def setUp(self): ) def test_default_values(self): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition assert "ElectricalSeriesRaw" in acquisition_module @@ -64,7 +66,7 @@ def test_default_values(self): def test_write_as_lfp(self): write_as = "lfp" - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as ) @@ -85,7 +87,7 @@ def test_write_as_lfp(self): def test_write_as_processing(self): write_as = "processed" - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as ) @@ -111,7 +113,7 @@ def test_write_multiple_electrical_series_from_same_electrode_group(self): ElectricalSeriesLFP=dict(name="ElectricalSeriesLFP", description="lfp series"), ) ) - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, metadata=metadata, @@ -121,7 +123,7 @@ def test_write_multiple_electrical_series_from_same_electrode_group(self): self.assertEqual(len(self.nwbfile.electrodes), len(self.test_recording_extractor.channel_ids)) self.assertIn("ElectricalSeriesRaw", self.nwbfile.acquisition) - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, metadata=metadata, @@ -141,7 +143,7 @@ def test_write_multiple_electrical_series_with_different_electrode_groups(self): ) original_groups = self.test_recording_extractor.get_channel_groups() self.test_recording_extractor.set_channel_groups(["group0"] * len(self.test_recording_extractor.channel_ids)) - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, metadata=metadata, @@ -158,7 +160,7 @@ def test_write_multiple_electrical_series_with_different_electrode_groups(self): ) # set new channel groups to create a new electrode_group self.test_recording_extractor.set_channel_groups(["group1"] * len(self.test_recording_extractor.channel_ids)) - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, metadata=metadata, @@ -183,7 +185,7 @@ def test_invalid_write_as_argument_assertion(self): reg_expression = f"'write_as' should be 'raw', 'processed' or 'lfp', but instead received value {write_as}" with self.assertRaisesRegex(AssertionError, reg_expression): - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None, write_as=write_as ) @@ -206,7 +208,9 @@ def setUp(self): ) def test_uniform_timestamps(self): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -219,7 +223,9 @@ def test_uniform_timestamps(self): def test_non_uniform_timestamps(self): expected_timestamps = np.array([0.0, 2.0, 10.0]) self.test_recording_extractor.set_times(times=expected_timestamps, with_warning=False) - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -265,7 +271,9 @@ def test_uniform_values(self): self.test_recording_extractor.set_channel_gains(gains=gains) self.test_recording_extractor.set_channel_offsets(offsets=offsets) - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -290,7 +298,9 @@ def test_uniform_non_default(self): self.test_recording_extractor.set_channel_gains(gains=gains) self.test_recording_extractor.set_channel_offsets(offsets=offsets) - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -315,7 +325,9 @@ def test_variable_gains(self): self.test_recording_extractor.set_channel_gains(gains=gains) self.test_recording_extractor.set_channel_offsets(offsets=offsets) - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -342,7 +354,9 @@ def test_null_offsets_in_recording_extractor(self): gains = self.gains_default self.test_recording_extractor.set_channel_gains(gains=gains) - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -373,7 +387,9 @@ def test_variable_offsets_assertion(self): reg_expression = "Recording extractors with heterogeneous offsets are not supported" with self.assertRaisesRegex(ValueError, reg_expression): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) class TestAddElectricalSeriesChunking(unittest.TestCase): @@ -405,7 +421,7 @@ def setUp(self): ) def test_default_iterative_writer(self): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile) + add_electrical_series_to_nwbfile(recording=self.test_recording_extractor, nwbfile=self.nwbfile) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -419,7 +435,7 @@ def test_default_iterative_writer(self): def test_iterator_opts_propagation(self): iterator_opts = dict(chunk_shape=(10, 3)) - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_opts=iterator_opts ) @@ -430,7 +446,9 @@ def test_iterator_opts_propagation(self): assert electrical_series_data_iterator.chunk_shape == iterator_opts["chunk_shape"] def test_hdmf_iterator(self): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type="v1") + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type="v1" + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -443,7 +461,9 @@ def test_hdmf_iterator(self): np.testing.assert_array_almost_equal(expected_data, extracted_data) def test_non_iterative_write(self): - add_electrical_series(recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + add_electrical_series_to_nwbfile( + recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition electrical_series = acquisition_module["ElectricalSeriesRaw"] @@ -476,7 +496,7 @@ def test_invalid_iterator_type_assertion(self): reg_expression = "iterator_type (.*?)" with self.assertRaisesRegex(ValueError, reg_expression): - add_electrical_series( + add_electrical_series_to_nwbfile( recording=self.test_recording_extractor, nwbfile=self.nwbfile, iterator_type=iterator_type ) @@ -513,7 +533,9 @@ def setUp(self): def test_default_values_single_segment(self): """This test that the names are written appropriately for the single segment case (numbers not added)""" - write_recording(recording=self.single_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + write_recording_to_nwbfile( + recording=self.single_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition assert "ElectricalSeriesRaw" in acquisition_module @@ -524,7 +546,9 @@ def test_default_values_single_segment(self): np.testing.assert_array_almost_equal(expected_data, extracted_data) def test_write_multiple_segments(self): - write_recording(recording=self.multiple_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None) + write_recording_to_nwbfile( + recording=self.multiple_segment_recording_extractor, nwbfile=self.nwbfile, iterator_type=None + ) acquisition_module = self.nwbfile.acquisition assert len(acquisition_module) == 2 @@ -547,7 +571,7 @@ def test_write_bool_properties(self): bool_property = np.array([False] * len(self.single_segment_recording_extractor.channel_ids)) bool_property[::2] = True self.single_segment_recording_extractor.set_property("test_bool", bool_property) - add_electrodes( + add_electrodes_to_nwbfile( recording=self.single_segment_recording_extractor, nwbfile=self.nwbfile, ) @@ -581,7 +605,7 @@ def setUp(self): ) def test_default_electrode_column_names(self): - add_electrodes(recording=self.base_recording, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.base_recording, nwbfile=self.nwbfile) expected_electrode_column_names = ["location", "group", "group_name", "channel_name", "rel_x", "rel_y"] actual_electrode_column_names = list(self.nwbfile.electrodes.colnames) @@ -595,8 +619,8 @@ def test_integer_channel_names(self): channel_ids=channel_ids, renamed_channel_ids=offest_channels_ids ) - add_electrodes(recording=self.base_recording, nwbfile=self.nwbfile) - add_electrodes(recording=recorder_with_offset_channels, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.base_recording, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recorder_with_offset_channels, nwbfile=self.nwbfile) expected_channel_names_in_electrodes_table = ["0", "1", "2", "3", "4", "5"] actual_channel_names_in_electrodes_table = list(self.nwbfile.electrodes["channel_name"].data) @@ -604,29 +628,29 @@ def test_integer_channel_names(self): def test_string_channel_names(self): """Ensure channel names merge correctly after appending when channel names are strings.""" - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) expected_channel_names_in_electrodes_table = ["a", "b", "c", "d", "e", "f"] actual_channel_names_in_electrodes_table = list(self.nwbfile.electrodes["channel_name"].data) self.assertListEqual(actual_channel_names_in_electrodes_table, expected_channel_names_in_electrodes_table) def test_non_overwriting_channel_names_property(self): - "add_electrodes function should not overwrite the recording object channel name property" + "add_electrodes_to_nwbfile function should not overwrite the recording object channel name property" channel_names = ["name a", "name b", "name c", "name d"] self.recording_1.set_property(key="channel_name", values=channel_names) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) expected_channel_names_in_electrodes_table = channel_names channel_names_in_electrodes_table = list(self.nwbfile.electrodes["channel_name"].data) self.assertListEqual(channel_names_in_electrodes_table, expected_channel_names_in_electrodes_table) def test_channel_group_names_table(self): - "add_electrodes function should add new rows if same channel names, but different group_names" - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + "add_electrodes_to_nwbfile function should add new rows if same channel names, but different group_names" + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) original_groups = self.recording_1.get_channel_groups() self.recording_1.set_channel_groups(["1"] * len(self.recording_1.channel_ids)) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) # reset channel_groups self.recording_1.set_channel_groups(original_groups) assert len(self.nwbfile.electrodes) == 2 * len(self.recording_1.channel_ids) @@ -643,14 +667,14 @@ def test_common_property_extension(self): self.recording_1.set_property(key="common_property", values=["value_1"] * self.num_channels) self.recording_2.set_property(key="common_property", values=["value_2"] * self.num_channels) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) actual_properties_in_electrodes_table = list(self.nwbfile.electrodes["common_property"].data) expected_properties_in_electrodes_table = ["value_1", "value_1", "value_1", "value_1", "value_2", "value_2"] self.assertListEqual(actual_properties_in_electrodes_table, expected_properties_in_electrodes_table) - def test_add_electrodes_addition(self): + def test_add_electrodes_addition_to_nwbfile(self): """ Keep the old logic of not allowing integer channel_ids to match electrodes.table.ids """ @@ -663,22 +687,22 @@ def test_add_electrodes_addition(self): values_dic.update(id=1, channel_name="1") self.nwbfile.add_electrode(**values_dic) # The self.base_recording channel_ids are [0, 1, 2, 3], so only '3' and '4' should be added - add_electrodes(recording=self.base_recording, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.base_recording, nwbfile=self.nwbfile) self.assertEqual(len(self.nwbfile.electrodes), len(self.base_recording.channel_ids)) def test_new_property_addition(self): """Add a property only available in a second recording.""" self.recording_2.set_property(key="added_property", values=["added_value"] * self.num_channels) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) actual_properties_in_electrodes_table = list(self.nwbfile.electrodes["added_property"].data) expected_properties_in_electrodes_table = ["", "", "added_value", "added_value", "added_value", "added_value"] self.assertListEqual(actual_properties_in_electrodes_table, expected_properties_in_electrodes_table) - def test_manual_row_adition_before_add_electrodes_function(self): - """Add some rows to the electrode tables before using the add_electrodes function""" + def test_manual_row_adition_before_add_electrodes_function_to_nwbfile(self): + """Add some rows to the electrode tables before using the add_electrodes_to_nwbfile function""" values_dic = self.defaults values_dic.update(id=123) @@ -687,16 +711,16 @@ def test_manual_row_adition_before_add_electrodes_function(self): values_dic.update(id=124) self.nwbfile.add_electrode(**values_dic) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) expected_ids = [123, 124, 2, 3, 4, 5] expected_names = ["123", "124", "a", "b", "c", "d"] self.assertListEqual(list(self.nwbfile.electrodes.id.data), expected_ids) self.assertListEqual(list(self.nwbfile.electrodes["channel_name"].data), expected_names) - def test_manual_row_adition_after_add_electrodes_function(self): - """Add some rows to the electrode table after using the add_electrodes function""" - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + def test_manual_row_adition_after_add_electrodes_function_to_nwbfile(self): + """Add some rows to the electrode table after using the add_electrodes_to_nwbfile function""" + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) values_dic = self.defaults @@ -715,8 +739,8 @@ def test_manual_row_adition_after_add_electrodes_function(self): self.assertListEqual(list(self.nwbfile.electrodes.id.data), expected_ids) self.assertListEqual(list(self.nwbfile.electrodes["channel_name"].data), expected_names) - def test_manual_row_adition_before_add_electrodes_function_optional_columns(self): - """Add some rows including optional columns to the electrode tables before using the add_electrodes function.""" + def test_manual_row_adition_before_add_electrodes_function_optional_columns_to_nwbfile(self): + """Add some rows including optional columns to the electrode tables before using the add_electrodes_to_nwbfile function.""" values_dic = self.defaults values_dic.update(id=123) @@ -726,7 +750,7 @@ def test_manual_row_adition_before_add_electrodes_function_optional_columns(self self.nwbfile.add_electrode(**values_dic, x=1.0, y=2.0, z=3.0) # recording_1 does not have x, y, z positions - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) expected_ids = [123, 124, 2, 3, 4, 5] expected_x = [0, 1, np.nan, np.nan, np.nan, np.nan] @@ -758,7 +782,7 @@ def test_row_matching_by_channel_name_with_existing_property(self): property_values = ["value_a", "value_b", "x", "y"] self.recording_1.set_property(key="property", values=property_values) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) # Remaining ids are filled positionally. expected_ids = [20, 21, 22, 3, 4] @@ -781,8 +805,8 @@ def test_adding_new_property_with_identifical_channels_but_different_groups(self recording2.set_property(key="added_property", values=["value"] * 3) - add_electrodes(recording=recording1, nwbfile=self.nwbfile) - add_electrodes(recording=recording2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording2, nwbfile=self.nwbfile) expected_property = ["", "", "", "value", "value", "value"] property = self.nwbfile.electrodes["added_property"].data @@ -809,7 +833,7 @@ def test_row_matching_by_channel_name_with_new_property(self): property_values = ["value_a", "value_b", "value_c", "value_d"] self.recording_1.set_property(key="property", values=property_values) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) # Remaining ids are filled positionally. expected_ids = [20, 21, 22, 3, 4] @@ -825,7 +849,7 @@ def test_adding_ragged_array_properties(self): ragged_array_values1 = [[1, 2], [3, 4], [5, 6], [7, 8]] self.recording_1.set_property(key="ragged_property", values=ragged_array_values1) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) written_values = self.nwbfile.electrodes.to_dataframe()["ragged_property"].to_list() np.testing.assert_array_equal(written_values, ragged_array_values1) @@ -836,7 +860,7 @@ def test_adding_ragged_array_properties(self): second_ragged_array_values = [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"], ["j", "k", "l"]] self.recording_2.set_property(key="ragged_property2", values=second_ragged_array_values) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) written_values = self.nwbfile.electrodes.to_dataframe()["ragged_property"].to_list() expected_values = [[1, 2], [3, 4], [5, 6], [7, 8], [9, 10], [11, 12]] @@ -861,7 +885,7 @@ def test_adding_doubled_ragged_arrays(self): ] self.recording_1.set_property(key="double_ragged_property", values=doubled_nested_array1) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile) written_values = self.nwbfile.electrodes.to_dataframe()["double_ragged_property"].to_list() np.testing.assert_array_equal(written_values, doubled_nested_array1) @@ -874,7 +898,7 @@ def test_adding_doubled_ragged_arrays(self): [[21, 22], [23, 24]], ] self.recording_2.set_property(key="double_ragged_property", values=doubled_nested_array2) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) written_values = self.nwbfile.electrodes.to_dataframe()["double_ragged_property"].to_list() @@ -899,7 +923,7 @@ def test_adding_doubled_ragged_arrays(self): # We add another properyt to recording 2 tat is not in recording 1 self.recording_2.set_property(key="double_ragged_property2", values=second_doubled_nested_array) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile) written_values = self.nwbfile.electrodes.to_dataframe()["double_ragged_property2"].to_list() @@ -933,8 +957,8 @@ def test_property_metadata_mismatch(self): ) ) - add_electrodes(recording=self.recording_1, nwbfile=self.nwbfile, metadata=metadata) - add_electrodes(recording=self.recording_2, nwbfile=self.nwbfile, metadata=metadata) + add_electrodes_to_nwbfile(recording=self.recording_1, nwbfile=self.nwbfile, metadata=metadata) + add_electrodes_to_nwbfile(recording=self.recording_2, nwbfile=self.nwbfile, metadata=metadata) actual_common_property_values = list(self.nwbfile.electrodes["common_property"].data) expected_common_property_values = ["value_1", "value_1", "value_1", "value_1", "value_2", "value_2"] @@ -953,7 +977,7 @@ def test_missing_int_values(self): recording1 = generate_recording(num_channels=2, durations=[1.0]) recording1 = recording1.rename_channels(new_channel_ids=["a", "b"]) recording1.set_property(key="complete_int_property", values=[1, 2]) - add_electrodes(recording=recording1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording1, nwbfile=self.nwbfile) expected_property = np.asarray([1, 2]) extracted_property = self.nwbfile.electrodes["complete_int_property"].data @@ -964,10 +988,10 @@ def test_missing_int_values(self): recording2.set_property(key="incomplete_int_property", values=[10, 11]) with self.assertRaises(ValueError): - add_electrodes(recording=recording2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording2, nwbfile=self.nwbfile) null_values_for_properties = {"complete_int_property": -1, "incomplete_int_property": -3} - add_electrodes( + add_electrodes_to_nwbfile( recording=recording2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties ) @@ -984,7 +1008,7 @@ def test_missing_bool_values(self): recording1 = generate_recording(num_channels=2) recording1 = recording1.rename_channels(new_channel_ids=["a", "b"]) recording1.set_property(key="complete_bool_property", values=[True, False]) - add_electrodes(recording=recording1, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording1, nwbfile=self.nwbfile) expected_property = np.asarray([True, False]) extracted_property = self.nwbfile.electrodes["complete_bool_property"].data.astype(bool) @@ -995,10 +1019,10 @@ def test_missing_bool_values(self): recording2.set_property(key="incomplete_bool_property", values=[True, False]) with self.assertRaises(ValueError): - add_electrodes(recording=recording2, nwbfile=self.nwbfile) + add_electrodes_to_nwbfile(recording=recording2, nwbfile=self.nwbfile) null_values_for_properties = {"complete_bool_property": False, "incomplete_bool_property": False} - add_electrodes( + add_electrodes_to_nwbfile( recording=recording2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties ) @@ -1035,25 +1059,25 @@ def setUp(self): def test_integer_unit_names(self): """Ensure add units_table gets the right units name for integer units ids.""" - add_units_table(sorting=self.base_sorting, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.base_sorting, nwbfile=self.nwbfile) expected_unit_names_in_units_table = ["0", "1", "2", "3"] unit_names_in_units_table = list(self.nwbfile.units["unit_name"].data) self.assertListEqual(unit_names_in_units_table, expected_unit_names_in_units_table) def test_string_unit_names(self): - """Ensure add_units_table gets the right units name for string units ids""" - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + """Ensure add_units_table_to_nwbfile gets the right units name for string units ids""" + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) expected_unit_names_in_units_table = ["a", "b", "c", "d"] unit_names_in_units_table = list(self.nwbfile.units["unit_name"].data) self.assertListEqual(unit_names_in_units_table, expected_unit_names_in_units_table) def test_non_overwriting_unit_names_sorting_property(self): - "add_units_table function should not overwrite the sorting object unit_name property" + "add_units_table_to_nwbfile function should not overwrite the sorting object unit_name property" unit_names = ["name a", "name b", "name c", "name d"] self.sorting_1.set_property(key="unit_name", values=unit_names) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) expected_unit_names_in_units_table = unit_names unit_names_in_units_table = list(self.nwbfile.units["unit_name"].data) @@ -1067,8 +1091,8 @@ def test_integer_unit_names_overwrite(self): unit_ids=unit_ids, renamed_unit_ids=offest_units_ids ) - add_units_table(sorting=self.base_sorting, nwbfile=self.nwbfile) - add_units_table(sorting=sorting_with_offset_unit_ids, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.base_sorting, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting_with_offset_unit_ids, nwbfile=self.nwbfile) expected_unit_names_in_units_table = ["0", "1", "2", "3", "4", "5"] unit_names_in_units_table = list(self.nwbfile.units["unit_name"].data) @@ -1076,8 +1100,8 @@ def test_integer_unit_names_overwrite(self): def test_string_unit_names_overwrite(self): """Ensure unit names merge correctly after appending when channel names are strings.""" - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) - add_units_table(sorting=self.sorting_2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_2, nwbfile=self.nwbfile) expected_unit_names_in_units_table = ["a", "b", "c", "d", "e", "f"] unit_names_in_units_table = list(self.nwbfile.units["unit_name"].data) @@ -1088,8 +1112,8 @@ def test_common_property_extension(self): self.sorting_1.set_property(key="common_property", values=["value_1"] * self.num_units) self.sorting_2.set_property(key="common_property", values=["value_2"] * self.num_units) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) - add_units_table(sorting=self.sorting_2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_2, nwbfile=self.nwbfile) properties_in_units_table = list(self.nwbfile.units["common_property"].data) expected_properties_in_units_table = ["value_1", "value_1", "value_1", "value_1", "value_2", "value_2"] @@ -1099,15 +1123,15 @@ def test_property_addition(self): """Add a property only available in a second sorting.""" self.sorting_2.set_property(key="added_property", values=["added_value"] * self.num_units) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) - add_units_table(sorting=self.sorting_2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_2, nwbfile=self.nwbfile) properties_in_units_table = list(self.nwbfile.units["added_property"].data) expected_properties_in_units_table = ["", "", "added_value", "added_value", "added_value", "added_value"] self.assertListEqual(properties_in_units_table, expected_properties_in_units_table) def test_units_table_extension_after_manual_unit_addition(self): - """Add some rows to the units tables before using the add_units_table function""" + """Add some rows to the units tables before using the add_units_table_to_nwbfile function""" values_dic = self.defaults values_dic.update(id=123, spike_times=[0, 1, 2]) @@ -1116,17 +1140,17 @@ def test_units_table_extension_after_manual_unit_addition(self): values_dic.update(id=124, spike_times=[2, 3, 4]) self.nwbfile.add_unit(**values_dic) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) expected_units_ids = [123, 124, 2, 3, 4, 5] expected_unit_names = ["123", "124", "a", "b", "c", "d"] self.assertListEqual(list(self.nwbfile.units.id.data), expected_units_ids) self.assertListEqual(list(self.nwbfile.units["unit_name"].data), expected_unit_names) - def test_manual_extension_after_add_units_table(self): - """Add some units to the units table after using the add_units_table function""" + def test_manual_extension_after_add_units_table_to_nwbfile(self): + """Add some units to the units table after using the add_units_table_to_nwbfile function""" - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) values_dic = self.defaults @@ -1147,7 +1171,7 @@ def test_manual_extension_after_add_units_table(self): def test_property_matching_by_unit_name_with_existing_property(self): """ - Add some units to the units tables before using the add_units_table function. + Add some units to the units tables before using the add_units_table_to_nwbfile function. Previous properties that are also available in the sorting are matched with unit_name """ @@ -1168,7 +1192,7 @@ def test_property_matching_by_unit_name_with_existing_property(self): property_values = ["value_a", "value_b", "x", "y"] self.sorting_1.set_property(key="property", values=property_values) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) # Properties correspond with unit names, ids are filled positionally expected_units_ids = [20, 21, 22, 3, 4] @@ -1181,13 +1205,13 @@ def test_property_matching_by_unit_name_with_existing_property(self): def test_add_existing_units(self): # test that additional units are not added if already in the nwbfile.units table - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) self.assertEqual(len(self.nwbfile.units), len(self.sorting_1.unit_ids)) def test_property_matching_by_unit_name_with_new_property(self): """ - Add some units to the units tables before using the add_units_table function. + Add some units to the units tables before using the add_units_table_to_nwbfile function. New properties in the sorter are matched by unit name """ @@ -1207,7 +1231,7 @@ def test_property_matching_by_unit_name_with_new_property(self): property_values = ["value_a", "value_b", "value_c", "value_d"] self.sorting_1.set_property(key="property", values=property_values) - add_units_table(sorting=self.sorting_1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=self.sorting_1, nwbfile=self.nwbfile) # Properties correspond with unit names, ids are filled positionally expected_units_ids = [20, 21, 22, 3, 4] @@ -1223,7 +1247,7 @@ def test_write_units_table_in_processing_module(self): units_table_name = "testing_processing" unit_table_description = "testing_description" - add_units_table( + add_units_table_to_nwbfile( sorting=self.base_sorting, nwbfile=self.nwbfile, units_table_name=units_table_name, @@ -1244,7 +1268,7 @@ def test_write_units_table_in_processing_module(self): def test_write_subset_units(self): """ """ subset_unit_ids = self.base_sorting.unit_ids[::2] - add_units_table( + add_units_table_to_nwbfile( sorting=self.base_sorting, nwbfile=self.nwbfile, unit_ids=subset_unit_ids, @@ -1258,7 +1282,7 @@ def test_write_bool_properties(self): bool_property = np.array([False] * len(self.base_sorting.unit_ids)) bool_property[::2] = True self.base_sorting.set_property("test_bool", bool_property) - add_units_table( + add_units_table_to_nwbfile( sorting=self.base_sorting, nwbfile=self.nwbfile, ) @@ -1274,7 +1298,7 @@ def test_adding_ragged_array_properties(self): ragged_array_values1 = [[1, 2], [3, 4], [5, 6], [7, 8]] sorting1.set_property(key="ragged_property", values=ragged_array_values1) - add_units_table(sorting=sorting1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting1, nwbfile=self.nwbfile) written_values = self.nwbfile.units.to_dataframe()["ragged_property"].to_list() np.testing.assert_array_equal(written_values, ragged_array_values1) @@ -1284,7 +1308,7 @@ def test_adding_ragged_array_properties(self): sorting2.set_property(key="ragged_property", values=ragged_array_values2) second_ragged_array_values = [["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"], ["j", "k", "l"]] sorting2.set_property(key="ragged_property2", values=second_ragged_array_values) - add_units_table(sorting=sorting2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting2, nwbfile=self.nwbfile) written_values = self.nwbfile.units.to_dataframe()["ragged_property"].to_list() expected_values = ragged_array_values1 + ragged_array_values2 @@ -1308,7 +1332,7 @@ def test_adding_doubled_ragged_arrays(self): doubled_nested_array = [[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]], [[13, 14], [15, 16]]] sorting1.set_property(key="double_ragged_property", values=doubled_nested_array) - add_units_table(sorting=sorting1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting1, nwbfile=self.nwbfile) written_values = self.nwbfile.units.to_dataframe()["double_ragged_property"].to_list() np.testing.assert_array_equal(written_values, doubled_nested_array) @@ -1323,7 +1347,7 @@ def test_adding_doubled_ragged_arrays(self): [["s", "t", "u"], ["v", "w", "x"]], ] sorting2.set_property(key="double_ragged_property2", values=second_doubled_nested_array) - add_units_table(sorting=sorting2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting2, nwbfile=self.nwbfile) written_values = self.nwbfile.units.to_dataframe()["double_ragged_property"].to_list() expected_values = doubled_nested_array + doubled_nested_array2 @@ -1343,7 +1367,7 @@ def test_missing_int_values(self): sorting1 = generate_sorting(num_units=2, durations=[1.0]) sorting1 = sorting1.rename_units(new_unit_ids=["a", "b"]) sorting1.set_property(key="complete_int_property", values=[1, 2]) - add_units_table(sorting=sorting1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting1, nwbfile=self.nwbfile) expected_property = np.asarray([1, 2]) extracted_property = self.nwbfile.units["complete_int_property"].data @@ -1354,10 +1378,12 @@ def test_missing_int_values(self): sorting2.set_property(key="incomplete_int_property", values=[10, 11]) with self.assertRaises(ValueError): - add_units_table(sorting=sorting2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting2, nwbfile=self.nwbfile) null_values_for_properties = {"complete_int_property": -1, "incomplete_int_property": -3} - add_units_table(sorting=sorting2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties) + add_units_table_to_nwbfile( + sorting=sorting2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties + ) expected_complete_property = np.asarray([1, 2, -1, -1]) expected_incomplete_property = np.asarray([-3, -3, 10, 11]) @@ -1372,7 +1398,7 @@ def test_missing_bool_values(self): sorting1 = generate_sorting(num_units=2, durations=[1.0]) sorting1 = sorting1.rename_units(new_unit_ids=["a", "b"]) sorting1.set_property(key="complete_bool_property", values=[True, False]) - add_units_table(sorting=sorting1, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting1, nwbfile=self.nwbfile) expected_property = np.asarray([True, False]) extracted_property = self.nwbfile.units["complete_bool_property"].data.astype(bool) @@ -1383,10 +1409,12 @@ def test_missing_bool_values(self): sorting2.set_property(key="incomplete_bool_property", values=[True, False]) with self.assertRaises(ValueError): - add_units_table(sorting=sorting2, nwbfile=self.nwbfile) + add_units_table_to_nwbfile(sorting=sorting2, nwbfile=self.nwbfile) null_values_for_properties = {"complete_bool_property": False, "incomplete_bool_property": False} - add_units_table(sorting=sorting2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties) + add_units_table_to_nwbfile( + sorting=sorting2, nwbfile=self.nwbfile, null_values_for_properties=null_values_for_properties + ) expected_complete_property = np.asarray([True, False, False, False]) expected_incomplete_property = np.asarray([False, False, True, False]) @@ -1488,7 +1516,7 @@ def _test_analyzer_write(self, analyzer, nwbfile, test_properties=True): def test_analyzer_single_segment(self): """This tests that the analyzer is written appropriately for the single segment case""" - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, write_electrical_series=True ) self._test_analyzer_write(self.single_segment_analyzer, self.nwbfile) @@ -1496,7 +1524,7 @@ def test_analyzer_single_segment(self): def test_analyzer_single_segment_sparse(self): """This tests that the analyzer is written appropriately for the single segment case""" - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer_sparse, nwbfile=self.nwbfile, write_electrical_series=True ) self._test_analyzer_write(self.single_segment_analyzer_sparse, self.nwbfile) @@ -1504,14 +1532,14 @@ def test_analyzer_single_segment_sparse(self): def test_analyzer_multiple_segments(self): """This tests that the analyzer is written appropriately for the multi segment case""" - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.multi_segment_analyzer, nwbfile=self.nwbfile, write_electrical_series=False ) self._test_analyzer_write(self.multi_segment_analyzer, self.nwbfile) def test_analyzer_multiple_segments_sparse(self): """This tests that the analyzer is written appropriately for the multi segment case""" - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.multi_segment_analyzer_sparse, nwbfile=self.nwbfile, write_electrical_series=False ) self._test_analyzer_write(self.multi_segment_analyzer_sparse, self.nwbfile) @@ -1519,7 +1547,7 @@ def test_analyzer_multiple_segments_sparse(self): def test_write_subset_units(self): """This tests that the analyzer is sliced properly based on unit_ids""" subset_unit_ids = self.single_segment_analyzer.unit_ids[::2] - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, unit_ids=subset_unit_ids ) self._test_analyzer_write(self.analyzer_slice, self.nwbfile, test_properties=False) @@ -1527,9 +1555,9 @@ def test_write_subset_units(self): self.assertEqual(len(self.nwbfile.units), len(subset_unit_ids)) self.assertTrue(all(str(unit_id) in self.nwbfile.units["unit_name"][:] for unit_id in subset_unit_ids)) - def test_write_recordingless(self): + def test_write_recordingless_to_write_recording_to_nwbfile(self): """This tests that the analyzer is written properly in recordingless mode""" - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.analyzer_recless, nwbfile=self.nwbfile, recording=self.analyzer_recless_recording, @@ -1539,19 +1567,19 @@ def test_write_recordingless(self): # check that not passing the recording raises and Exception with self.assertRaises(Exception) as context: - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.analyzer_recless, nwbfile=self.nwbfile, recording=self.analyzer_recless_recording, write_electrical_series=True, ) - # def test_write_sorting_analyzer_to_file(self): + # def test_write_sorting_analyzer_to_file_to_write_sorting_analyzer_to_nwbfile(self): # """This tests that the analyzer is written to file""" # metadata = get_default_nwbfile_metadata() # metadata["NWBFile"]["session_start_time"] = datetime.now() - # write_sorting_analyzer( + # write_sorting_analyzer_to_nwbfile( # sorting_analyzer=self.single_segment_analyzer, # nwbfile_path=self.nwbfile_path, # write_electrical_series=True, @@ -1568,7 +1596,7 @@ def test_write_multiple_probes_without_electrical_series(self): # we write the first set of waveforms as belonging to group 0 original_channel_groups = self.analyzer_recless_recording.get_channel_groups() self.analyzer_recless_recording.set_channel_groups([0] * len(self.analyzer_recless_recording.channel_ids)) - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.analyzer_recless, nwbfile=self.nwbfile, write_electrical_series=False, @@ -1576,7 +1604,7 @@ def test_write_multiple_probes_without_electrical_series(self): ) # now we set new channel groups to mimic a different probe and call the function again self.analyzer_recless_recording.set_channel_groups([1] * len(self.analyzer_recless_recording.channel_ids)) - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.analyzer_recless, nwbfile=self.nwbfile, write_electrical_series=False, @@ -1609,26 +1637,26 @@ def test_write_multiple_probes_with_electrical_series(self): ElectricalSeriesRaw2=dict(name="ElectricalSeriesRaw2", description="lfp series"), ) ) - add_electrical_series_kwargs1 = dict(es_key="ElectricalSeriesRaw1") - write_sorting_analyzer( + add_electrical_series_kwargs1b = dict(es_key="ElectricalSeriesRaw1") + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, write_electrical_series=True, metadata=metadata, - add_electrical_series_kwargs=add_electrical_series_kwargs1, + add_electrical_series_kwargs=add_electrical_series_kwargs1b, ) self.assertEqual(len(self.nwbfile.electrodes), len(recording.channel_ids)) self.assertIn("ElectricalSeriesRaw1", self.nwbfile.acquisition) # now we set new channel groups to mimic a different probe and call the function again self.single_segment_analyzer.recording.set_channel_groups([1] * len(recording.channel_ids)) - add_electrical_series_kwargs2 = dict(es_key="ElectricalSeriesRaw2") - write_sorting_analyzer( + add_electrical_series_kwargs2_to_add_electrical_series_to_nwbfile = dict(es_key="ElectricalSeriesRaw2") + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, write_electrical_series=True, metadata=metadata, - add_electrical_series_kwargs=add_electrical_series_kwargs2, + add_electrical_series_kwargs=add_electrical_series_kwargs2_to_add_electrical_series_to_nwbfile, ) # check that we have 2 groups self.assertEqual(len(self.nwbfile.electrode_groups), 2) @@ -1653,7 +1681,7 @@ def test_missing_electrode_group(self): """This tests that analyzer is correctly written even if the 'group' property is not available""" groups = self.single_segment_analyzer.recording.get_channel_groups() self.single_segment_analyzer.recording.delete_property("group") - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, ) @@ -1663,7 +1691,7 @@ def test_group_name_property(self): """This tests that the 'group_name' property is correctly used to instantiate electrode groups""" num_channels = len(self.single_segment_analyzer.recording.channel_ids) self.single_segment_analyzer.recording.set_property("group_name", ["my-fancy-group"] * num_channels) - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, ) @@ -1674,7 +1702,7 @@ def test_group_name_property(self): def test_units_table_name(self): """This tests the units naming exception""" with self.assertRaises(Exception) as context: - write_sorting_analyzer( + write_sorting_analyzer_to_nwbfile( sorting_analyzer=self.single_segment_analyzer, nwbfile=self.nwbfile, write_as="units",