Merge pull request #2 from h-mayorquin/intan_heberto_helping_zach

Intan heberto helping zach

Author: zm711

neo/io/asciisignalio.py

@@ -402,7 +402,8 @@ def write_block(self, block):
         if len(block.segments) > 1:
             raise ValueError(
                 "Can only write blocks containing a single segment."
-                f" This block contains {len(block.segments)} segments.")
+                f" This block contains {len(block.segments)} segments."
+            )
         self.write_segment(block.segments[0])
 
     def write_metadata(self, metadata_filename=None):

neo/io/basefromrawio.py

@@ -103,7 +103,7 @@ def read_block(
             By default None since the default is dependant on the IO
         load_waveforms: bool, default: False
             Determines whether SpikeTrains.waveforms is created
-        
+
         Returns
         -------
         bl: neo.core.Block
@@ -241,7 +241,9 @@ def read_segment(
         """
 
         if lazy:
-            assert time_slice is None, "For lazy=True you must specify a time_slice when LazyObject.load(time_slice=...)"
+            assert (
+                time_slice is None
+            ), "For lazy=True you must specify a time_slice when LazyObject.load(time_slice=...)"
 
             assert (
                 not load_waveforms

neo/io/baseio.py

@@ -132,7 +132,7 @@ def read(self, lazy: bool = False, **kargs):
             Whether to lazily load the data (True) or to load into memory (False)
         kargs: dict
             IO specific additional arguments
-        
+
         Returns
         ------
         block_list: list[neo.core.Block]
@@ -163,20 +163,20 @@ def write(self, bl, **kargs):
             The neo Block to be written
         kargs: dict
             IO specific additional arguments
-            
+
         """
         if Block in self.writeable_objects:
             if isinstance(bl, Sequence):
-                assert hasattr(self, "write_all_blocks"), (
-                    f"{self.__class__.__name__} does not offer to store a sequence of blocks"
-                )
+                assert hasattr(
+                    self, "write_all_blocks"
+                ), f"{self.__class__.__name__} does not offer to store a sequence of blocks"
                 self.write_all_blocks(bl, **kargs)
             else:
                 self.write_block(bl, **kargs)
         elif Segment in self.writeable_objects:
             assert len(bl.segments) == 1, (
                 f"{self.__class__.__name__} is based on segment so if you try to write a block it "
-                + "must contain only one Segment"  
+                + "must contain only one Segment"
             )
             self.write_segment(bl.segments[0], **kargs)
         else:

neo/io/elphyio.py

@@ -4166,7 +4166,7 @@ def read_segment(self, episode):
                 t_stop=signal.t_stop * getattr(pq, signal.x_unit.strip().decode()),
                 # sampling_rate = signal.sampling_frequency * pq.kHz,
                 sampling_period=signal.sampling_period * getattr(pq, x_unit),
-                channel_name=f"episode {int(episode + 1)}, channel { int(channel + 1)}"
+                channel_name=f"episode {int(episode + 1)}, channel { int(channel + 1)}",
             )
             segment.analogsignals.append(analog_signal)
         # create a spiketrain for each
@@ -4195,9 +4195,7 @@ def read_event(self, episode, evt):
             Index of the event.
         """
         event = self.elphy_file.get_event(episode, evt)
-        neo_event = Event(
-            times=event.times * pq.s, channel_name=f"episode {episode + 1}, event channel {evt + 1}"
-        )
+        neo_event = Event(times=event.times * pq.s, channel_name=f"episode {episode + 1}, event channel {evt + 1}")
         return neo_event
 
     def read_spiketrain(self, episode, spk):

neo/io/igorproio.py

@@ -59,9 +59,7 @@ def __init__(self, filename=None, parse_notes=None):
         """
         BaseIO.__init__(self)
         filename = pathlib.Path(filename)
-        assert filename.suffix[1:] in self.extensions, (
-            f"Only the following extensions are supported: {self.extensions}" 
-        )
+        assert filename.suffix[1:] in self.extensions, f"Only the following extensions are supported: {self.extensions}"
         self.filename = filename
         self.extension = filename.suffix[1:]
         self.parse_notes = parse_notes

neo/io/neomatlabio.py

@@ -248,7 +248,7 @@ def __init__(self, filename=None):
             raise ImportError(
                 "your scipy version is too old to support "
                 + "MatlabIO, you need at least 0.12.0. "
-                + f"You have {scipy.version.version}" 
+                + f"You have {scipy.version.version}"
             )
 
         BaseIO.__init__(self)

neo/io/nestio.py

@@ -79,9 +79,7 @@ def __init__(self, filenames=None):
             if ext in self.extensions:
                 if ext in self.avail_IOs:
                     raise ValueError(
-                        f'Received multiple files with "{ext}" '
-                        "extension. Can only load single file of "
-                        "this type."
+                        f'Received multiple files with "{ext}" ' "extension. Can only load single file of " "this type."
                     )
                 self.avail_IOs[ext] = ColumnIO(filename)
             self.avail_formats[ext] = path
@@ -130,7 +128,7 @@ def __read_analogsignals(
             raise ValueError(
                 "One or more columns have been specified to contain "
                 "the same data. Columns were specified to {column_list_no_None}."
-                "" 
+                ""
             )
 
         # extracting condition and sorting parameters for raw data loading

neo/io/nixio.py

@@ -679,9 +679,7 @@ def _write_channelview(self, chview, nixblock, nixgroup):
 
         # create a new data array if this channelview was not saved yet
         if not nix_name in self._view_map:
-            channels = nixblock.create_data_array(
-                f"{nix_name}.index", "neo.channelview.index", data=chview.index
-            )
+            channels = nixblock.create_data_array(f"{nix_name}.index", "neo.channelview.index", data=chview.index)
 
             nixmt = nixblock.create_multi_tag(nix_name, "neo.channelview", positions=channels)
 

neo/io/nwbio.py

@@ -481,7 +481,7 @@ def _write_block(self, block):
         """
         electrodes = self._write_electrodes(self._nwbfile, block)
         if not block.name:
-            block.name = f"block{self.blocks_written}" 
+            block.name = f"block{self.blocks_written}"
         for i, segment in enumerate(block.segments):
             assert segment.block is block
             if not segment.name:
@@ -593,7 +593,8 @@ def _write_signal(self, nwbfile, signal, electrodes):
             )
         else:
             raise TypeError(
-                f"signal has type { signal.__class__.__name__}, should be AnalogSignal or IrregularlySampledSignal")
+                f"signal has type { signal.__class__.__name__}, should be AnalogSignal or IrregularlySampledSignal"
+            )
         nwb_group = signal.annotations.get("nwb_group", "acquisition")
         add_method_map = {"acquisition": self._nwbfile.add_acquisition, "stimulus": self._nwbfile.add_stimulus}
         if nwb_group in add_method_map:

neo/rawio/axographrawio.py

@@ -196,10 +196,10 @@ class AxographRawIO(BaseRawIO):
         ...                                           i_start=0,
         ...                                           i_stop=1024,
         ...                                           channel_names=channel_names)
-        
+
         >>> float_chunk = r.rescale_signal_raw_to_float(raw_chunk,
         ...                                             dtype='float64',
-        ...                                             channel_names=channel_names)  
+        ...                                             channel_names=channel_names)
         >>> print(float_chunk)
 
         >>> # get event markers
@@ -210,7 +210,7 @@ class AxographRawIO(BaseRawIO):
         >>> # get interval bars
         >>> ep_raw_times, ep_raw_durations, ep_labels = reader.get_event_timestamps(event_channel_index=1)
         >>> ep_times = reader.rescale_event_timestamp(ep_raw_times, dtype='float64')
-        >>> ep_durations = reader.rescale_epoch_duration(ep_raw_durations, dtype='float64') 
+        >>> ep_durations = reader.rescale_epoch_duration(ep_raw_durations, dtype='float64')
         >>> print([ep for ep in zip(ep_times, ep_durations, ep_labels)])
 
         >>> # get notes
@@ -564,12 +564,14 @@ def _scan_axograph_file(self):
             #   format version 3
             if header_id == "AxGr":
                 format_ver, n_cols = f.read_f("HH")
-                assert (
-                    format_ver == 1 or format_ver == 2
-                ), f'mismatch between header identifier "{header_id}" and format ' f'version "{format_ver}"!'
+                assert format_ver == 1 or format_ver == 2, (
+                    f'mismatch between header identifier "{header_id}" and format ' f'version "{format_ver}"!'
+                )
             elif header_id == "axgx":
                 format_ver, n_cols = f.read_f("ll")
-                assert format_ver >= 3, f'mismatch between header identifier "{header_id}" and format ' f'version "{format_ver}"!'
+                assert format_ver >= 3, (
+                    f'mismatch between header identifier "{header_id}" and format ' f'version "{format_ver}"!'
+                )
             else:
                 raise NotImplementedError(f'unimplemented file header identifier "{header_id}"!')
             self.info["format_ver"] = format_ver
@@ -666,8 +668,7 @@ def _scan_axograph_file(self):
                         first_value, increment = f.read_f("ff")
 
                         self.logger.debug(f"interval: {increment}, freq: {1 / increment}")
-                        self.logger.debug(
-                            f"start: {first_value}, end: {first_value + increment * (n_points - 1)}")
+                        self.logger.debug(f"start: {first_value}, end: {first_value + increment * (n_points - 1)}")
 
                         # assume this is the time column
                         t_start, sampling_period = first_value, increment
@@ -702,9 +703,7 @@ def _scan_axograph_file(self):
                         first_value, increment = f.read_f("dd")
 
                         self.logger.debug(f"interval: {increment}, freq: {1 / increment}")
-                        self.logger.debug(
-                            "start: {first_value}, end: {first_value + increment * (n_points - 1)}"
-                        )
+                        self.logger.debug("start: {first_value}, end: {first_value + increment * (n_points - 1)}")
 
                         if i == 0:
 
@@ -792,9 +791,7 @@ def _scan_axograph_file(self):
                     first_value = array[0]
 
                     self.logger.debug(f"interval: {increment}, freq: {1 / increment}")
-                    self.logger.debug(
-                        f"start: {first_value}, end: {first_value + increment * (n_points - 1)}"
-                    )
+                    self.logger.debug(f"start: {first_value}, end: {first_value + increment * (n_points - 1)}")
 
                     t_start, sampling_period = first_value, increment
                     self.info["t_start"] = t_start
@@ -993,9 +990,7 @@ def _scan_axograph_file(self):
 
                     self.logger.debug(f"old_unknown_episode_list: {old_unknown_episode_list}")
                     if n_episodes2 != n_episodes:
-                        self.logger.debug(
-                           f"n_episodes2 ({n_episodes2}) and n_episodes ({n_episodes}) " "differ!"
-                           )
+                        self.logger.debug(f"n_episodes2 ({n_episodes2}) and n_episodes ({n_episodes}) " "differ!")
 
                 # another list of episode indexes with unknown purpose
                 unknown_episode_list = []
@@ -1062,8 +1057,10 @@ def _scan_axograph_file(self):
                     assert font_settings_info["setting1"] in [
                         FONT_BOLD,
                         FONT_NOT_BOLD,
-                    ], f"expected setting1 ({ font_settings_info['setting1']}) to have value FONT_BOLD " f"({FONT_BOLD}) or FONT_NOT_BOLD ({FONT_NOT_BOLD})"
-
+                    ], (
+                        f"expected setting1 ({ font_settings_info['setting1']}) to have value FONT_BOLD "
+                        f"({FONT_BOLD}) or FONT_NOT_BOLD ({FONT_NOT_BOLD})"
+                    )
 
                     # size is stored 10 times bigger than real value
                     font_settings_info["size"] = font_settings_info["size"] / 10.0