<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _prep_noise_interpolants(self):
 """Construct interpolated sensitivity curves This will construct the interpolated sensitivity curves using scipy.interpolate.interp1d. It will add wd noise if that is requested. Raises: ValueError: ``len(noise_type_in) != len(sensitivity_curves)`` ValueError: Issue with sensitivity curve type provided. """

        noise_lists = {}
        self.noise_interpolants = {}

        if isinstance(self.sensitivity_curves, str):
            self.sensitivity_curves = [self.sensitivity_curves]

        if isinstance(self.noise_type_in, list):
            if len(self.noise_type_in) != len(self.sensitivity_curves):
                raise ValueError('noise_type_in must have same shape as sensitivity_curves if it is'
                                 + 'provided as a list.'
                                 + 'If all curves are of the same type, provide a string.')

        else:
            assert isinstance(self.noise_type_in, str)
            self.noise_type_in = [self.noise_type_in for _ in self.sensitivity_curves]

        if isinstance(self.signal_type, str):
            self.signal_type = [self.signal_type]

        # read in all the noise curves
        for num, sc in enumerate(self.sensitivity_curves):
            if isinstance(sc, str):
                f, h_n = read_noise_curve(sc, noise_type_in=self.noise_type_in[num],
                                          noise_type_out='char_strain')
                if sc[-4:] == '.txt':
                    key = sc.split('.')[0].split('/')[-1]
                else:
                    key = sc
            elif isinstance(sc, list):
                # TODO: add to docs if inputing special noise curve, make sure its char_strain
                f, h_n = sc
                key = str(num)
            else:
                raise ValueError('Sensitivity curves must either be string'
                                 + 'or list containing f_n and asd_n.')

            noise_lists[key] = [f, h_n]

        # add wd noise
        if str(self.add_wd_noise).lower() in ['true', 'both', 'yes']:
            if isinstance(self.wd_noise, str):
                f_n_wd, h_n_wd = read_noise_curve(self.wd_noise,
                                                  noise_type_in=self.wd_noise_type_in,
                                                  noise_type_out='char_strain')
            elif isinstance(self, wd_noise, list):
                f_n_wd, h_n_wd = self.wd_noise

            trans_dict = {}
            for sc in noise_lists.keys():
                f_n, h_n = noise_lists[sc]
                if self.add_wd_noise.lower() == 'both':
                    trans_dict[sc] = [f_n, h_n]

                f_n, h_n = combine_with_wd_noise(f_n, h_n, f_n_wd, h_n_wd)
                trans_dict[sc + '_wd'] = [f_n, h_n]

            noise_lists = trans_dict

        # interpolate
        for sc in noise_lists:
            f_n, h_n = noise_lists[sc]
            self.noise_interpolants[sc] = (interpolate.interp1d(f_n, h_n,
                                           bounds_error=False, fill_value=1e30))
        return