def align_words(
            self,
            audio: Union[str, np.ndarray, torch.Tensor, bytes, AudioLoader],
            result: Union[WhisperResult, List[dict]],
            normalize_text: bool = True,
            inplace: bool = True
    ) -> WhisperResult:
        """
        Align segments of plain text or tokens with audio at word-level at specified start and end of each segment.

        This is a version of ``align()`` that confines each segment to a range of timestamps which eliminates the need
        for the fallback mechanisms used in ``align()``. This makes this method is drastically faster than ``align()``
        and reduces word-timstamp errors if the provided start and end timestamps of each segment is accurate.

        Parameters
        ----------
        audio : str or numpy.ndarray or torch.Tensor or bytes or AudioLoader
            Path/URL to the audio file, the audio waveform, or bytes of audio file or
            instance of :class:`stable_whisper.audio.AudioLoader`.
            If audio is :class:`numpy.ndarray` or :class:`torch.Tensor`, the audio must be already at sampled to 16kHz.
        result : stable_whisper.result.WhisperResult or list of dict
            Instance of :class:`stable_whisper.result.WhisperResult` or List of dictionaries with start, end, and text.
        normalize_text : bool or dict, default True
            Whether to normalize text of each segment.
        inplace : bool, default True
            Whether to update ``result`` with new timestamps if it is an instance of
            :class:`stable_whisper.result.WhisperResult`.

        Returns
        -------
        stable_whisper.result.WhisperResult
            All timestamps, words, probabilities, and other data from the alignment of ``audio``.
            Same object as ``result`` if ``inplace=True`` (default) and ``result`` is a ``WhisperResult``.

        """
        self._reset()
        result, segment_tokens = self._load_result(result, normalize_text, inplace)
        self._load_audio(audio)
        self._load_nonspeech_detector()

        with tqdm(
                total=self._initial_duration,
                unit='sec',
                disable=self.options.progress.verbose is not False,
                desc='Align Words'
        ) as tqdm_pbar:

            for segment, curr_tokens in zip(result.segments, segment_tokens):
                self._time_offset = segment.start
                self._seek_sample = round(segment.start * self.sample_rate)
                end = segment.end
                if segment.duration == 0:
                    self._update_pbar(tqdm_pbar, end)
                    continue
                segment_samples = round(segment.duration * self.sample_rate)
                audio_segment = self.audio_loader.next_chunk(self._seek_sample, segment_samples)
                if audio_segment is None:
                    break
                self.nonspeech_predictor.predict(audio=audio_segment, offset=self._time_offset)

                curr_word_tokens = tokens_to_word_tokens(
                    curr_tokens,
                    self.decode,
                    self.split_words_by_space,
                    self.options.post.prepend_punctuations,
                    self.options.post.append_punctuations
                )
                words_timings = self._compute_timestamps(audio_segment, curr_word_tokens)
                segment.words = [WordTiming(**w.__dict__) for w in words_timings]
                self._update_pbar(tqdm_pbar, end)
            self._update_pbar(tqdm_pbar, end, True)

        self.audio_loader.terminate()
        self.nonspeech_predictor.finalize_timings()
        result.reassign_ids()
        self._suppress_silence(result)
        result.regroup(self.options.post.regroup)

        return result

        Align segments of plain text or tokens with audio at word-level at specified start and end of each segment.

        This is a version of ``align()`` that confines each segment to a range of timestamps which eliminates the need
        for the fallback mechanisms used in ``align()``. This makes this method is drastically faster than ``align()``
        and reduces word-timstamp errors if the provided start and end timestamps of each segment is accurate.

        Parameters
        ----------
        audio : str or numpy.ndarray or torch.Tensor or bytes or AudioLoader
            Path/URL to the audio file, the audio waveform, or bytes of audio file or
            instance of :class:`stable_whisper.audio.AudioLoader`.
            If audio is :class:`numpy.ndarray` or :class:`torch.Tensor`, the audio must be already at sampled to 16kHz.
        result : stable_whisper.result.WhisperResult or list of dict
            Instance of :class:`stable_whisper.result.WhisperResult` or List of dictionaries with start, end, and text.
        normalize_text : bool or dict, default True
            Whether to normalize text of each segment.
        inplace : bool, default True
            Whether to update ``result`` with new timestamps if it is an instance of
            :class:`stable_whisper.result.WhisperResult`.

        Returns
        -------
        stable_whisper.result.WhisperResult
            All timestamps, words, probabilities, and other data from the alignment of ``audio``.
            Same object as ``result`` if ``inplace=True`` (default) and ``result`` is a ``WhisperResult``.

        
stable_whisper/non_whisper/alignment.py