How to use the spikeextractors.RecordingExtractor.__init__ function in spikeextractors

def __init__(self, file_path, sampling_frequency, numchan, dtype, recording_channels=None,
                 time_axis=0, geom=None, offset=0, gain=None, is_filtered=None):
        RecordingExtractor.__init__(self)
        self._datfile = Path(file_path)
        self._time_axis = time_axis
        self._dtype = str(dtype)
        self._sampling_frequency = float(sampling_frequency)
        self._gain = gain
        self._numchan = numchan
        self._geom = geom
        self._offset = offset
        self._timeseries = read_binary(self._datfile, numchan, dtype, time_axis, offset)

        # keep track of filter status when dumping
        if is_filtered is not None:
            self.is_filtered = is_filtered
        else:
            self.is_filtered = False

def __init__(self, file_path):
        assert HAVE_MEA1k, self.installation_mesg
        RecordingExtractor.__init__(self)
        self._file_path = file_path
        self._fs = None
        self._positions = None
        self._recordings = None
        self._filehandle = None
        self._mapping = None
        self._signals = None
        self._version = None
        self._initialize()
        self._kwargs = {'file_path': str(Path(file_path).absolute())}

def __init__(self, recording):
        self._recording = recording
        RecordingExtractor.__init__(self)
        self.copy_channel_properties(recording)
        self.is_filtered = self._recording.is_filtered

        self._kwargs = {'recording': recording.make_serialized_dict()}

def __init__(self, recording, triggers, ms_before=0.5, ms_after=3):
        if not isinstance(recording, RecordingExtractor):
            raise ValueError("'recording' must be a RecordingExtractor")
        self._recording = recording
        self._triggers = np.array(triggers)
        self._ms_before = ms_before
        self._ms_after = ms_after
        RecordingExtractor.__init__(self)
        self.copy_channel_properties(recording=self._recording)
        self.is_filtered = self._recording.is_filtered

        self._kwargs = {'recording': recording.make_serialized_dict(), 'triggers': triggers,
                        'ms_before': ms_before, 'ms_after': ms_after}

def __init__(self, recording, scalar=1., offset=0., dtype=None):
        if not isinstance(recording, RecordingExtractor):
            raise ValueError("'recording' must be a RecordingExtractor")
        self._scalar = scalar
        self._offset = offset
        if dtype is None:
            self._dtype = recording.get_dtype()
        else:
            self._dtype = dtype
        RecordingExtractor.__init__(self)
        self._recording = recording
        self.copy_channel_properties(recording=self._recording)
        self.is_filtered = self._recording.is_filtered

        self._kwargs = {'recording': recording.make_serialized_dict(), 'scalar': scalar, 'offset': offset,
                        'dtype': dtype}