


"""simple docstring"""





import json
import os
import shutil
import tempfile
import unittest
from multiprocessing import get_context
from pathlib import Path

import datasets
import numpy as np
from datasets import load_dataset
from parameterized import parameterized

from transformers import AutoProcessor
from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.testing_utils import require_pyctcdecode, require_torch, require_torchaudio, slow
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_pyctcdecode_available, is_torch_available

from ..wavaveca.test_feature_extraction_wavaveca import floats_list


if is_pyctcdecode_available():
   from huggingface_hub import snapshot_download
   from pyctcdecode import BeamSearchDecoderCTC

   from transformers.models.wavaveca_with_lm import WavaVecaProcessorWithLM
   from transformers.models.wavaveca_with_lm.processing_wavaveca_with_lm import WavaVecaDecoderWithLMOutput

if is_torch_available():
   from transformers import WavaVecaForCTC

@require_pyctcdecode
class 			lowercase_	(			unittest.TestCase    ):







      def 					_lowerCAmelCase							(   self			:				Tuple     ):
        lowerCAmelCase__     :     str										=       "| <pad> <unk> <s> </s> a b c d e f g h i j k".split()
        lowerCAmelCase__     :     List[str]										=       dict(zip(_lowercase		,	range(len(_lowercase     )     )     )     )

        lowerCAmelCase__     :     str										=       {
            "unk_token": "<unk>",
            "bos_token": "<s>",
            "eos_token": "</s>",
        }
        lowerCAmelCase__     :     int										=       {
            "feature_size": 1,
            "padding_value": 0.0,
            "sampling_rate": 1_6_0_0_0,
            "return_attention_mask": False,
            "do_normalize": True,
        }

        lowerCAmelCase__     :     str										=       tempfile.mkdtemp()
        lowerCAmelCase__     :     Optional[int]										=       os.path.join(self.tmpdirname		,	VOCAB_FILES_NAMES["vocab_file"]     )
        lowerCAmelCase__     :     Optional[Any]										=       os.path.join(self.tmpdirname		,	_lowercase     )
        with open(self.vocab_file		,	"w"		,	encoding="utf-8"     ) as fp:
          fp.write(json.dumps(_lowercase     ) + "\n"     )

        with open(self.feature_extraction_file		,	"w"		,	encoding="utf-8"     ) as fp:
          fp.write(json.dumps(_lowercase     ) + "\n"     )

        # load decoder from hub
        lowerCAmelCase__     :     Dict										=       "hf-internal-testing/ngram-beam-search-decoder"







      def 					_lowerCAmelCase							(   self			:				List[Any]		,	**_lowercase			:				Optional[int]     ):
        lowerCAmelCase__     :     List[str]										=       self.add_kwargs_tokens_map.copy()
        kwargs.update(_lowercase     )
        return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname		,	**_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Tuple		,	**_lowercase			:				Any     ):
        return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname		,	**_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Tuple		,	**_lowercase			:				List[Any]     ):
        return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name		,	**_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Tuple     ):
        shutil.rmtree(self.tmpdirname     )







      def 					_lowerCAmelCase							(   self			:				Optional[int]     ):
        lowerCAmelCase__     :     Any										=       self.get_tokenizer()
        lowerCAmelCase__     :     Tuple										=       self.get_feature_extractor()
        lowerCAmelCase__     :     Union[str, Any]										=       self.get_decoder()

        lowerCAmelCase__     :     Optional[Any]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        processor.save_pretrained(self.tmpdirname     )
        lowerCAmelCase__     :     Optional[int]										=       WavaVecaProcessorWithLM.from_pretrained(self.tmpdirname     )

        # tokenizer
        self.assertEqual(processor.tokenizer.get_vocab()		,	tokenizer.get_vocab()     )
        self.assertIsInstance(processor.tokenizer		,	_lowercase     )

        # feature extractor
        self.assertEqual(processor.feature_extractor.to_json_string()		,	feature_extractor.to_json_string()     )
        self.assertIsInstance(processor.feature_extractor		,	_lowercase     )

        # decoder
        self.assertEqual(processor.decoder._alphabet.labels		,	decoder._alphabet.labels     )
        self.assertEqual(
            processor.decoder.model_container[decoder._model_key]._unigram_set		,	decoder.model_container[decoder._model_key]._unigram_set		,	)
        self.assertIsInstance(processor.decoder		,	_lowercase     )







      def 					_lowerCAmelCase							(   self			:				List[str]     ):
        lowerCAmelCase__     :     Optional[Any]										=       WavaVecaProcessorWithLM(
            tokenizer=self.get_tokenizer()		,	feature_extractor=self.get_feature_extractor()		,	decoder=self.get_decoder()     )
        processor.save_pretrained(self.tmpdirname     )

        # make sure that error is thrown when decoder alphabet doesn't match
        lowerCAmelCase__     :     str										=       WavaVecaProcessorWithLM.from_pretrained(
            self.tmpdirname		,	alpha=5.0		,	beta=3.0		,	score_boundary=-7.0		,	unk_score_offset=3     )

        # decoder
        self.assertEqual(processor.language_model.alpha		,	5.0     )
        self.assertEqual(processor.language_model.beta		,	3.0     )
        self.assertEqual(processor.language_model.score_boundary		,	-7.0     )
        self.assertEqual(processor.language_model.unk_score_offset		,	3     )







      def 					_lowerCAmelCase							(   self			:				Any     ):
        lowerCAmelCase__     :     List[str]										=       self.get_tokenizer()
        # add token to trigger raise
        tokenizer.add_tokens(["xx"]     )
        with self.assertRaisesRegex(_lowercase		,	"include"     ):
          WavaVecaProcessorWithLM(
              tokenizer=_lowercase		,	feature_extractor=self.get_feature_extractor()		,	decoder=self.get_decoder()     )







      def 					_lowerCAmelCase							(   self			:				str     ):
        lowerCAmelCase__     :     Dict										=       self.get_feature_extractor()
        lowerCAmelCase__     :     str										=       self.get_tokenizer()
        lowerCAmelCase__     :     Tuple										=       self.get_decoder()

        lowerCAmelCase__     :     Union[str, Any]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     int										=       floats_list((3, 1_0_0_0)     )

        lowerCAmelCase__     :     int										=       feature_extractor(_lowercase		,	return_tensors="np"     )
        lowerCAmelCase__     :     int										=       processor(_lowercase		,	return_tensors="np"     )

        for key in input_feat_extract.keys():
          self.assertAlmostEqual(input_feat_extract[key].sum()		,	input_processor[key].sum()		,	delta=1e-2     )







      def 					_lowerCAmelCase							(   self			:				str     ):
        lowerCAmelCase__     :     Dict										=       self.get_feature_extractor()
        lowerCAmelCase__     :     List[str]										=       self.get_tokenizer()
        lowerCAmelCase__     :     Optional[Any]										=       self.get_decoder()

        lowerCAmelCase__     :     Optional[int]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     Optional[int]										=       "This is a test string"

        lowerCAmelCase__     :     Union[str, Any]										=       processor(text=_lowercase     )

        lowerCAmelCase__     :     Any										=       tokenizer(_lowercase     )

        for key in encoded_tok.keys():
          self.assertListEqual(encoded_tok[key]		,	encoded_processor[key]     )







      def 					_lowerCAmelCase							(   self			:				List[Any]		,	_lowercase			:				List[Any]=(2, 1_0, 1_6)		,	_lowercase			:				List[Any]=7_7     ):
        np.random.seed(_lowercase     )
        return np.random.rand(*_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Union[str, Any]     ):
        lowerCAmelCase__     :     Union[str, Any]										=       self.get_feature_extractor()
        lowerCAmelCase__     :     int										=       self.get_tokenizer()
        lowerCAmelCase__     :     Tuple										=       self.get_decoder()

        lowerCAmelCase__     :     Optional[int]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     List[Any]										=       self._get_dummy_logits(shape=(1_0, 1_6)		,	seed=1_3     )

        lowerCAmelCase__     :     str										=       processor.decode(_lowercase     )

        lowerCAmelCase__     :     Tuple										=       decoder.decode_beams(_lowercase     )[0]

        self.assertEqual(decoded_decoder[0]		,	decoded_processor.text     )
        self.assertEqual("</s> <s> </s>"		,	decoded_processor.text     )
        self.assertEqual(decoded_decoder[-2]		,	decoded_processor.logit_score     )
        self.assertEqual(decoded_decoder[-1]		,	decoded_processor.lm_score     )







      @parameterized.expand([[None], ["fork"], ["spawn"]]     )
      def 					_lowerCAmelCase							(   self			:				Tuple		,	_lowercase			:				Optional[Any]     ):
        lowerCAmelCase__     :     List[Any]										=       self.get_feature_extractor()
        lowerCAmelCase__     :     Dict										=       self.get_tokenizer()
        lowerCAmelCase__     :     Union[str, Any]										=       self.get_decoder()

        lowerCAmelCase__     :     List[Any]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     str										=       self._get_dummy_logits()

        # note: pool should be instantiated *after* Wav2Vec2ProcessorWithLM.
        #       otherwise, the LM won't be available to the pool's sub-processes.
        # manual logic used to allow parameterized test for both pool=None and pool=Pool(...)
        if pool_context is None:
          lowerCAmelCase__     :     Optional[int]										=       processor.batch_decode(_lowercase     )
        else:
          with get_context(_lowercase     ).Pool() as pool:
            lowerCAmelCase__     :     Optional[Any]										=       processor.batch_decode(_lowercase		,	_lowercase     )

        lowerCAmelCase__     :     Optional[int]										=       list(_lowercase     )

        with get_context("fork"     ).Pool() as p:
          lowerCAmelCase__     :     Optional[Any]										=       decoder.decode_beams_batch(_lowercase		,	_lowercase     )

        lowerCAmelCase__					,		lowerCAmelCase__					,		lowerCAmelCase__     :     Optional[Any]										=       [], [], []
        for beams in decoded_beams:
          texts_decoder.append(beams[0][0]     )
          logit_scores_decoder.append(beams[0][-2]     )
          lm_scores_decoder.append(beams[0][-1]     )

        self.assertListEqual(_lowercase		,	decoded_processor.text     )
        self.assertListEqual(["<s> <s> </s>", "<s> <s> <s>"]		,	decoded_processor.text     )
        self.assertListEqual(_lowercase		,	decoded_processor.logit_score     )
        self.assertListEqual(_lowercase		,	decoded_processor.lm_score     )







      def 					_lowerCAmelCase							(   self			:				Union[str, Any]     ):
        lowerCAmelCase__     :     int										=       self.get_feature_extractor()
        lowerCAmelCase__     :     Union[str, Any]										=       self.get_tokenizer()
        lowerCAmelCase__     :     List[Any]										=       self.get_decoder()

        lowerCAmelCase__     :     int										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     List[Any]										=       self._get_dummy_logits()

        lowerCAmelCase__     :     List[str]										=       1_5
        lowerCAmelCase__     :     List[str]										=       -20.0
        lowerCAmelCase__     :     str										=       -4.0

        lowerCAmelCase__     :     Optional[int]										=       processor.batch_decode(
            _lowercase		,	beam_width=_lowercase		,	beam_prune_logp=_lowercase		,	token_min_logp=_lowercase		,	)
        lowerCAmelCase__     :     str										=       decoded_processor_out.text

        lowerCAmelCase__     :     Union[str, Any]										=       list(_lowercase     )

        with get_context("fork"     ).Pool() as pool:
          lowerCAmelCase__     :     Union[str, Any]										=       decoder.decode_beams_batch(
              _lowercase		,	_lowercase		,	beam_width=_lowercase		,	beam_prune_logp=_lowercase		,	token_min_logp=_lowercase		,	)

        lowerCAmelCase__     :     int										=       [d[0][0] for d in decoded_decoder_out]
        lowerCAmelCase__     :     List[str]										=       [d[0][2] for d in decoded_decoder_out]
        lowerCAmelCase__     :     List[Any]										=       [d[0][3] for d in decoded_decoder_out]

        self.assertListEqual(_lowercase		,	_lowercase     )
        self.assertListEqual(["</s> <s> <s>", "<s> <s> <s>"]		,	_lowercase     )

        self.assertTrue(np.array_equal(_lowercase		,	decoded_processor_out.logit_score     )     )
        self.assertTrue(np.allclose([-20.054, -18.447]		,	_lowercase		,	atol=1e-3     )     )

        self.assertTrue(np.array_equal(_lowercase		,	decoded_processor_out.lm_score     )     )
        self.assertTrue(np.allclose([-15.554, -13.9474]		,	_lowercase		,	atol=1e-3     )     )







      def 					_lowerCAmelCase							(   self			:				str     ):
        lowerCAmelCase__     :     Dict										=       self.get_feature_extractor()
        lowerCAmelCase__     :     Any										=       self.get_tokenizer()
        lowerCAmelCase__     :     Any										=       self.get_decoder()

        lowerCAmelCase__     :     List[Any]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        lowerCAmelCase__     :     List[Any]										=       self._get_dummy_logits()

        lowerCAmelCase__     :     Any										=       2.0
        lowerCAmelCase__     :     Dict										=       5.0
        lowerCAmelCase__     :     int										=       -20.0
        lowerCAmelCase__     :     Tuple										=       True

        lowerCAmelCase__     :     Optional[int]										=       processor.batch_decode(
            _lowercase		,	alpha=_lowercase		,	beta=_lowercase		,	unk_score_offset=_lowercase		,	lm_score_boundary=_lowercase		,	)
        lowerCAmelCase__     :     int										=       decoded_processor_out.text

        lowerCAmelCase__     :     List[str]										=       list(_lowercase     )
        decoder.reset_params(
            alpha=_lowercase		,	beta=_lowercase		,	unk_score_offset=_lowercase		,	lm_score_boundary=_lowercase		,	)

        with get_context("fork"     ).Pool() as pool:
          lowerCAmelCase__     :     List[str]										=       decoder.decode_beams_batch(
              _lowercase		,	_lowercase		,	)

        lowerCAmelCase__     :     str										=       [d[0][0] for d in decoded_decoder_out]

        self.assertListEqual(_lowercase		,	_lowercase     )
        self.assertListEqual(["<s> </s> <s> </s> </s>", "</s> </s> <s> </s> </s>"]		,	_lowercase     )
        lowerCAmelCase__     :     List[str]										=       processor.decoder.model_container[processor.decoder._model_key]
        self.assertEqual(lm_model.alpha		,	2.0     )
        self.assertEqual(lm_model.beta		,	5.0     )
        self.assertEqual(lm_model.unk_score_offset		,	-20.0     )
        self.assertEqual(lm_model.score_boundary		,	_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Optional[Any]     ):
        lowerCAmelCase__     :     int										=       WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"     )

        lowerCAmelCase__     :     Any										=       processor.decoder.model_container[processor.decoder._model_key]
        lowerCAmelCase__     :     Dict										=       Path(language_model._kenlm_model.path.decode("utf-8"     )     ).parent.parent.absolute()

        lowerCAmelCase__     :     str										=       os.listdir(_lowercase     )
        lowerCAmelCase__     :     Union[str, Any]										=       ["alphabet.json", "language_model"]

        downloaded_decoder_files.sort()
        expected_decoder_files.sort()

        # test that only decoder relevant files from
        # https://huggingface.co/hf-internal-testing/processor_with_lm/tree/main
        # are downloaded and none of the rest (e.g. README.md, ...)
        self.assertListEqual(_lowercase		,	_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Optional[int]     ):
        lowerCAmelCase__     :     List[str]										=       snapshot_download("hf-internal-testing/processor_with_lm"     )

        lowerCAmelCase__     :     int										=       WavaVecaProcessorWithLM.from_pretrained(_lowercase     )

        lowerCAmelCase__     :     Tuple										=       processor.decoder.model_container[processor.decoder._model_key]
        lowerCAmelCase__     :     Union[str, Any]										=       Path(language_model._kenlm_model.path.decode("utf-8"     )     ).parent.parent.absolute()

        lowerCAmelCase__     :     Dict										=       os.listdir(_lowercase     )
        lowerCAmelCase__     :     str										=       os.listdir(_lowercase     )

        local_decoder_files.sort()
        expected_decoder_files.sort()

        # test that both decoder form hub and local files in cache are the same
        self.assertListEqual(_lowercase		,	_lowercase     )







      def 					_lowerCAmelCase							(   self			:				Optional[int]     ):
        lowerCAmelCase__     :     Optional[int]										=       WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"     )
        lowerCAmelCase__     :     Union[str, Any]										=       AutoProcessor.from_pretrained("hf-internal-testing/processor_with_lm"     )

        lowerCAmelCase__     :     Optional[Any]										=       floats_list((3, 1_0_0_0)     )

        lowerCAmelCase__     :     str										=       processor_wavaveca(_lowercase		,	return_tensors="np"     )
        lowerCAmelCase__     :     List[Any]										=       processor_auto(_lowercase		,	return_tensors="np"     )

        for key in input_wavaveca.keys():
          self.assertAlmostEqual(input_wavaveca[key].sum()		,	input_auto[key].sum()		,	delta=1e-2     )

        lowerCAmelCase__     :     List[Any]										=       self._get_dummy_logits()

        lowerCAmelCase__     :     Optional[int]										=       processor_wavaveca.batch_decode(_lowercase     )
        lowerCAmelCase__     :     Dict										=       processor_auto.batch_decode(_lowercase     )

        self.assertListEqual(decoded_wavaveca.text		,	decoded_auto.text     )







      def 					_lowerCAmelCase							(   self			:				Union[str, Any]     ):
        lowerCAmelCase__     :     str										=       self.get_feature_extractor()
        lowerCAmelCase__     :     Optional[int]										=       self.get_tokenizer()
        lowerCAmelCase__     :     List[str]										=       self.get_decoder()

        lowerCAmelCase__     :     Optional[Any]										=       WavaVecaProcessorWithLM(tokenizer=_lowercase		,	feature_extractor=_lowercase		,	decoder=_lowercase     )

        self.assertListEqual(
            processor.model_input_names		,	feature_extractor.model_input_names		,	msg="`processor` and `feature_extractor` model input names do not match"		,	)







      @staticmethod
      def 					_lowerCAmelCase							(   _lowercase			:				List[str]		,	_lowercase			:				Tuple     ):
        lowerCAmelCase__     :     List[str]										=       [d[key] for d in offsets]
        return retrieved_list







      def 					_lowerCAmelCase							(   self			:				int     ):
        lowerCAmelCase__     :     Optional[Any]										=       WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"     )
        lowerCAmelCase__     :     List[str]										=       self._get_dummy_logits()[0]

        lowerCAmelCase__     :     str										=       processor.decode(_lowercase		,	output_word_offsets=_lowercase     )
        # check Wav2Vec2CTCTokenizerOutput keys for word
        self.assertEqual(len(outputs.keys()     )		,	4     )
        self.assertTrue("text" in outputs     )
        self.assertTrue("word_offsets" in outputs     )
        self.assertTrue(isinstance(_lowercase		,	_lowercase     )     )

        self.assertEqual(" ".join(self.get_from_offsets(outputs["word_offsets"]		,	"word"     )     )		,	outputs.text     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]		,	"word"     )		,	["<s>", "<s>", "</s>"]     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]		,	"start_offset"     )		,	[0, 2, 4]     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"]		,	"end_offset"     )		,	[1, 3, 5]     )







      def 					_lowerCAmelCase							(   self			:				Optional[int]     ):
        lowerCAmelCase__     :     Optional[int]										=       WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"     )
        lowerCAmelCase__     :     Optional[int]										=       self._get_dummy_logits()

        lowerCAmelCase__     :     int										=       processor.batch_decode(_lowercase		,	output_word_offsets=_lowercase     )

        # check Wav2Vec2CTCTokenizerOutput keys for word
        self.assertEqual(len(outputs.keys()     )		,	4     )
        self.assertTrue("text" in outputs     )
        self.assertTrue("word_offsets" in outputs     )
        self.assertTrue(isinstance(_lowercase		,	_lowercase     )     )

        self.assertListEqual(
            [" ".join(self.get_from_offsets(_lowercase		,	"word"     )     ) for o in outputs["word_offsets"]]		,	outputs.text     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]		,	"word"     )		,	["<s>", "<s>", "</s>"]     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]		,	"start_offset"     )		,	[0, 2, 4]     )
        self.assertListEqual(self.get_from_offsets(outputs["word_offsets"][0]		,	"end_offset"     )		,	[1, 3, 5]     )







      @slow
      @require_torch
      @require_torchaudio
      def 					_lowerCAmelCase							(   self			:				Any     ):
        import torch

        lowerCAmelCase__     :     str										=       load_dataset("common_voice"		,	"en"		,	split="train"		,	streaming=_lowercase     )
        lowerCAmelCase__     :     int										=       ds.cast_column("audio"		,	datasets.Audio(sampling_rate=1_6_0_0_0     )     )
        lowerCAmelCase__     :     Union[str, Any]										=       iter(_lowercase     )
        lowerCAmelCase__     :     Tuple										=       next(_lowercase     )

        lowerCAmelCase__     :     str										=       AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm"     )
        lowerCAmelCase__     :     List[Any]										=       WavaVecaForCTC.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm"     )

        # compare to filename `common_voice_en_100038.mp3` of dataset viewer on https://huggingface.co/datasets/common_voice/viewer/en/train
        lowerCAmelCase__     :     str										=       processor(sample["audio"]["array"]		,	return_tensors="pt"     ).input_values

        with torch.no_grad():
          lowerCAmelCase__     :     Union[str, Any]										=       model(_lowercase     ).logits.cpu().numpy()

        lowerCAmelCase__     :     Dict										=       processor.decode(logits[0]		,	output_word_offsets=_lowercase     )

        lowerCAmelCase__     :     Dict										=       model.config.inputs_to_logits_ratio / processor.feature_extractor.sampling_rate
        lowerCAmelCase__     :     Any										=       [
            {
                "start_time": d["start_offset"] * time_offset,
                "end_time": d["end_offset"] * time_offset,
                "word": d["word"],
            }
            for d in output["word_offsets"]
        ]

        lowerCAmelCase__     :     str										=       "WHY DOES MILISANDRA LOOK LIKE SHE WANTS TO CONSUME JOHN SNOW ON THE RIVER AT THE WALL"

        # output words
        self.assertEqual(" ".join(self.get_from_offsets(_lowercase		,	"word"     )     )		,	_lowercase     )
        self.assertEqual(" ".join(self.get_from_offsets(_lowercase		,	"word"     )     )		,	output.text     )

        # output times
        lowerCAmelCase__     :     int										=       torch.tensor(self.get_from_offsets(_lowercase		,	"start_time"     )     )
        lowerCAmelCase__     :     str										=       torch.tensor(self.get_from_offsets(_lowercase		,	"end_time"     )     )

        # fmt: off
        lowerCAmelCase__     :     Tuple										=       torch.tensor([1.4199, 1.6599, 2.2599, 3.0, 3.24, 3.5999, 3.7999, 4.0999, 4.26, 4.94, 5.28, 5.6599, 5.78, 5.94, 6.32, 6.5399, 6.6599]     )
        lowerCAmelCase__     :     int										=       torch.tensor([1.5399, 1.8999, 2.9, 3.16, 3.5399, 3.72, 4.0199, 4.1799, 4.76, 5.1599, 5.5599, 5.6999, 5.86, 6.1999, 6.38, 6.6199, 6.94]     )
        # fmt: on

        self.assertTrue(torch.allclose(_lowercase		,	_lowercase		,	atol=0.01     )     )
        self.assertTrue(torch.allclose(_lowercase		,	_lowercase		,	atol=0.01     )     )




import baseaa





def 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						bytes:


						'''simple docstring'''






						return baseaa.baaencode(string.encode("utf-8"			)			)





def 						_lowerCAmelCase							(     _lowerCAmelCase			)    ->						str:


						'''simple docstring'''






						return baseaa.baadecode(_lowerCAmelCase			).decode("utf-8"			)


if __name__ == "__main__":
	A				:       Dict      =  'Hello World!'
	A				:       Any      =  baseaa_encode(test)
	print(encoded)

	A				:       Optional[int]      =  baseaa_decode(encoded)
	print(decoded)





