





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        _a    (    unittest.TestCase):

      """simple docstring"""


      def 			UpperCAmelCase_       (		self:			Dict					):
          '''simple docstring'''


          UpperCamelCase__:	int					=     "| <pad> <unk> <s> </s> a b c d e f g h i j k".split()
          UpperCamelCase__:	str					=     dict(zip(__lowerCamelCase	,    range(len(__lowerCamelCase					)					)					)					)

          UpperCamelCase__:	Union[str, Any]					=     {
              "unk_token": "<unk>",
              "bos_token": "<s>",
              "eos_token": "</s>",
          }
          UpperCamelCase__:	Any					=     {
              "feature_size": 1,
              "padding_value": 0.0,
              "sampling_rate": 1_6000,
              "return_attention_mask": False,
              "do_normalize": True,
          }

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

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

          # load decoder from hub
          UpperCamelCase__:	List[str]					=     "hf-internal-testing/ngram-beam-search-decoder"






      def 			UpperCAmelCase_       (		self:			Optional[Any]	,    **__lowerCamelCase:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     self.add_kwargs_tokens_map.copy()
          kwargs.update(__lowerCamelCase					)
          return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname	,    **__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			List[Any]	,    **__lowerCamelCase:			Optional[Any]					):
          '''simple docstring'''


          return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname	,    **__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			List[str]	,    **__lowerCamelCase:			List[Any]					):
          '''simple docstring'''


          return BeamSearchDecoderCTC.load_from_hf_hub(self.decoder_name	,    **__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          shutil.rmtree(self.tmpdirname					)






      def 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     self.get_tokenizer()
          UpperCamelCase__:	List[str]					=     self.get_feature_extractor()
          UpperCamelCase__:	List[str]					=     self.get_decoder()

          UpperCamelCase__:	List[str]					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

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

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

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

          # 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	,    __lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			str					):
          '''simple docstring'''


          UpperCamelCase__:	str					=     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
          UpperCamelCase__:	Any					=     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 			UpperCAmelCase_       (		self:			Optional[Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     self.get_tokenizer()
          # add token to trigger raise
          tokenizer.add_tokens(["xx"]					)
          with self.assertRaisesRegex(__lowerCamelCase	,    "include"					):
              WavaVecaProcessorWithLM(
                  tokenizer=__lowerCamelCase	,    feature_extractor=self.get_feature_extractor()	,    decoder=self.get_decoder()					)






      def 			UpperCAmelCase_       (		self:			Dict					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[int]					=     self.get_feature_extractor()
          UpperCamelCase__:	Any					=     self.get_tokenizer()
          UpperCamelCase__:	str					=     self.get_decoder()

          UpperCamelCase__:	Any					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	Optional[Any]					=     floats_list((3, 1000)					)

          UpperCamelCase__:	List[str]					=     feature_extractor(__lowerCamelCase	,    return_tensors="np"					)
          UpperCamelCase__:	Optional[Any]					=     processor(__lowerCamelCase	,    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 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Tuple					=     self.get_feature_extractor()
          UpperCamelCase__:	Any					=     self.get_tokenizer()
          UpperCamelCase__:	List[str]					=     self.get_decoder()

          UpperCamelCase__:	Dict					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	Optional[Any]					=     "This is a test string"

          UpperCamelCase__:	Optional[int]					=     processor(text=__lowerCamelCase					)

          UpperCamelCase__:	List[Any]					=     tokenizer(__lowerCamelCase					)

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






      def 			UpperCAmelCase_       (		self:			Any	,    __lowerCamelCase:			str=(2, 10, 16)	,    __lowerCamelCase:			Any=77					):
          '''simple docstring'''


          np.random.seed(__lowerCamelCase					)
          return np.random.rand(*__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Tuple					):
          '''simple docstring'''


          UpperCamelCase__:	Dict					=     self.get_feature_extractor()
          UpperCamelCase__:	Dict					=     self.get_tokenizer()
          UpperCamelCase__:	Union[str, Any]					=     self.get_decoder()

          UpperCamelCase__:	List[str]					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	List[Any]					=     self._get_dummy_logits(shape=(10, 16)	,    seed=13					)

          UpperCamelCase__:	List[Any]					=     processor.decode(__lowerCamelCase					)

          UpperCamelCase__:	Any					=     decoder.decode_beams(__lowerCamelCase					)[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 			UpperCAmelCase_       (		self:			Tuple	,    __lowerCamelCase:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	Union[str, Any]					=     self.get_feature_extractor()
          UpperCamelCase__:	Union[str, Any]					=     self.get_tokenizer()
          UpperCamelCase__:	Optional[Any]					=     self.get_decoder()

          UpperCamelCase__:	Optional[Any]					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	Any					=     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:
              UpperCamelCase__:	int					=     processor.batch_decode(__lowerCamelCase					)
          else:
              with get_context(__lowerCamelCase					).Pool() as pool:
                  UpperCamelCase__:	Dict					=     processor.batch_decode(__lowerCamelCase	,    __lowerCamelCase					)

          UpperCamelCase__:	List[str]					=     list(__lowerCamelCase					)

          with get_context("fork"					).Pool() as p:
              UpperCamelCase__:	Dict					=     decoder.decode_beams_batch(__lowerCamelCase	,    __lowerCamelCase					)

          UpperCamelCase__				, UpperCamelCase__				, UpperCamelCase__:	List[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(__lowerCamelCase	,    decoded_processor.text					)
          self.assertListEqual(["<s> <s> </s>", "<s> <s> <s>"]	,    decoded_processor.text					)
          self.assertListEqual(__lowerCamelCase	,    decoded_processor.logit_score					)
          self.assertListEqual(__lowerCamelCase	,    decoded_processor.lm_score					)






      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[int]					=     self.get_feature_extractor()
          UpperCamelCase__:	Optional[int]					=     self.get_tokenizer()
          UpperCamelCase__:	int					=     self.get_decoder()

          UpperCamelCase__:	int					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	Union[str, Any]					=     self._get_dummy_logits()

          UpperCamelCase__:	Dict					=     15
          UpperCamelCase__:	Dict					=     -20.0
          UpperCamelCase__:	Any					=     -4.0

          UpperCamelCase__:	Optional[int]					=     processor.batch_decode(
              __lowerCamelCase	,    beam_width=__lowerCamelCase	,    beam_prune_logp=__lowerCamelCase	,    token_min_logp=__lowerCamelCase	,    )
          UpperCamelCase__:	Union[str, Any]					=     decoded_processor_out.text

          UpperCamelCase__:	str					=     list(__lowerCamelCase					)

          with get_context("fork"					).Pool() as pool:
              UpperCamelCase__:	Tuple					=     decoder.decode_beams_batch(
                  __lowerCamelCase	,    __lowerCamelCase	,    beam_width=__lowerCamelCase	,    beam_prune_logp=__lowerCamelCase	,    token_min_logp=__lowerCamelCase	,    )

          UpperCamelCase__:	Tuple					=     [d[0][0] for d in decoded_decoder_out]
          UpperCamelCase__:	Any					=     [d[0][2] for d in decoded_decoder_out]
          UpperCamelCase__:	Dict					=     [d[0][3] for d in decoded_decoder_out]

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

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

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






      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	List[Any]					=     self.get_feature_extractor()
          UpperCamelCase__:	Optional[Any]					=     self.get_tokenizer()
          UpperCamelCase__:	List[Any]					=     self.get_decoder()

          UpperCamelCase__:	List[Any]					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

          UpperCamelCase__:	Dict					=     self._get_dummy_logits()

          UpperCamelCase__:	Optional[int]					=     2.0
          UpperCamelCase__:	str					=     5.0
          UpperCamelCase__:	int					=     -20.0
          UpperCamelCase__:	Optional[Any]					=     True

          UpperCamelCase__:	Dict					=     processor.batch_decode(
              __lowerCamelCase	,    alpha=__lowerCamelCase	,    beta=__lowerCamelCase	,    unk_score_offset=__lowerCamelCase	,    lm_score_boundary=__lowerCamelCase	,    )
          UpperCamelCase__:	Dict					=     decoded_processor_out.text

          UpperCamelCase__:	Optional[Any]					=     list(__lowerCamelCase					)
          decoder.reset_params(
              alpha=__lowerCamelCase	,    beta=__lowerCamelCase	,    unk_score_offset=__lowerCamelCase	,    lm_score_boundary=__lowerCamelCase	,    )

          with get_context("fork"					).Pool() as pool:
              UpperCamelCase__:	Optional[int]					=     decoder.decode_beams_batch(
                  __lowerCamelCase	,    __lowerCamelCase	,    )

          UpperCamelCase__:	List[str]					=     [d[0][0] for d in decoded_decoder_out]

          self.assertListEqual(__lowerCamelCase	,    __lowerCamelCase					)
          self.assertListEqual(["<s> </s> <s> </s> </s>", "</s> </s> <s> </s> </s>"]	,    __lowerCamelCase					)
          UpperCamelCase__:	Dict					=     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	,    __lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Dict					):
          '''simple docstring'''


          UpperCamelCase__:	Tuple					=     WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"					)

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

          UpperCamelCase__:	Optional[Any]					=     os.listdir(__lowerCamelCase					)
          UpperCamelCase__:	str					=     ["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(__lowerCamelCase	,    __lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     snapshot_download("hf-internal-testing/processor_with_lm"					)

          UpperCamelCase__:	int					=     WavaVecaProcessorWithLM.from_pretrained(__lowerCamelCase					)

          UpperCamelCase__:	int					=     processor.decoder.model_container[processor.decoder._model_key]
          UpperCamelCase__:	List[str]					=     Path(language_model._kenlm_model.path.decode("utf-8"					)					).parent.parent.absolute()

          UpperCamelCase__:	Dict					=     os.listdir(__lowerCamelCase					)
          UpperCamelCase__:	int					=     os.listdir(__lowerCamelCase					)

          local_decoder_files.sort()
          expected_decoder_files.sort()

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






      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"					)
          UpperCamelCase__:	Tuple					=     AutoProcessor.from_pretrained("hf-internal-testing/processor_with_lm"					)

          UpperCamelCase__:	Any					=     floats_list((3, 1000)					)

          UpperCamelCase__:	Union[str, Any]					=     processor_wavaveca(__lowerCamelCase	,    return_tensors="np"					)
          UpperCamelCase__:	Tuple					=     processor_auto(__lowerCamelCase	,    return_tensors="np"					)

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

          UpperCamelCase__:	Optional[Any]					=     self._get_dummy_logits()

          UpperCamelCase__:	int					=     processor_wavaveca.batch_decode(__lowerCamelCase					)
          UpperCamelCase__:	int					=     processor_auto.batch_decode(__lowerCamelCase					)

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






      def 			UpperCAmelCase_       (		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	List[Any]					=     self.get_feature_extractor()
          UpperCamelCase__:	Optional[Any]					=     self.get_tokenizer()
          UpperCamelCase__:	Dict					=     self.get_decoder()

          UpperCamelCase__:	Optional[int]					=     WavaVecaProcessorWithLM(tokenizer=__lowerCamelCase	,    feature_extractor=__lowerCamelCase	,    decoder=__lowerCamelCase					)

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






      @staticmethod
      def 			UpperCAmelCase_       (		__lowerCamelCase:			Optional[int]	,    __lowerCamelCase:			Optional[Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     [d[key] for d in offsets]
          return retrieved_list






      def 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


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

          UpperCamelCase__:	List[Any]					=     processor.decode(__lowerCamelCase	,    output_word_offsets=__lowerCamelCase					)
          # 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(__lowerCamelCase	,    __lowerCamelCase					)					)

          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 			UpperCAmelCase_       (		self:			Union[str, Any]					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     WavaVecaProcessorWithLM.from_pretrained("hf-internal-testing/processor_with_lm"					)
          UpperCamelCase__:	Optional[Any]					=     self._get_dummy_logits()

          UpperCamelCase__:	Optional[int]					=     processor.batch_decode(__lowerCamelCase	,    output_word_offsets=__lowerCamelCase					)

          # 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(__lowerCamelCase	,    __lowerCamelCase					)					)

          self.assertListEqual(
              [" ".join(self.get_from_offsets(__lowerCamelCase	,    "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 			UpperCAmelCase_       (		self:			List[str]					):
          '''simple docstring'''


          import torch

          UpperCamelCase__:	Any					=     load_dataset("common_voice"	,    "en"	,    split="train"	,    streaming=__lowerCamelCase					)
          UpperCamelCase__:	Optional[Any]					=     ds.cast_column("audio"	,    datasets.Audio(sampling_rate=1_6000					)					)
          UpperCamelCase__:	Any					=     iter(__lowerCamelCase					)
          UpperCamelCase__:	List[Any]					=     next(__lowerCamelCase					)

          UpperCamelCase__:	Optional[int]					=     AutoProcessor.from_pretrained("patrickvonplaten/wav2vec2-base-100h-with-lm"					)
          UpperCamelCase__:	Optional[int]					=     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
          UpperCamelCase__:	Optional[Any]					=     processor(sample["audio"]["array"]	,    return_tensors="pt"					).input_values

          with torch.no_grad():
              UpperCamelCase__:	int					=     model(__lowerCamelCase					).logits.cpu().numpy()

          UpperCamelCase__:	Union[str, Any]					=     processor.decode(logits[0]	,    output_word_offsets=__lowerCamelCase					)

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

          UpperCamelCase__:	Any					=     "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(__lowerCamelCase	,    "word"					)					)	,    __lowerCamelCase					)
          self.assertEqual(" ".join(self.get_from_offsets(__lowerCamelCase	,    "word"					)					)	,    output.text					)

          # output times
          UpperCamelCase__:	List[str]					=     torch.tensor(self.get_from_offsets(__lowerCamelCase	,    "start_time"					)					)
          UpperCamelCase__:	Optional[int]					=     torch.tensor(self.get_from_offsets(__lowerCamelCase	,    "end_time"					)					)

          # fmt: off
          UpperCamelCase__:	str					=     torch.tensor([1.4_199, 1.6_599, 2.2_599, 3.0, 3.24, 3.5_999, 3.7_999, 4.0_999, 4.26, 4.94, 5.28, 5.6_599, 5.78, 5.94, 6.32, 6.5_399, 6.6_599]					)
          UpperCamelCase__:	List[Any]					=     torch.tensor([1.5_399, 1.8_999, 2.9, 3.16, 3.5_399, 3.72, 4.0_199, 4.1_799, 4.76, 5.1_599, 5.5_599, 5.6_999, 5.86, 6.1_999, 6.38, 6.6_199, 6.94]					)
          # fmt: on

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








from __future__ import annotations

from typing import Any




class        _a    :

      """simple docstring"""


      def __init__(		self:			Optional[int]	,    __lowerCamelCase:			int					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[Any]					=     num_of_nodes
          UpperCamelCase__:	list[list[int]]					=     []
          UpperCamelCase__:	dict[int, int]					=     {}






      def 			UpperCAmelCase_       (		self:			Any	,    __lowerCamelCase:			int	,    __lowerCamelCase:			int	,    __lowerCamelCase:			int					):
          '''simple docstring'''


          self.m_edges.append([u_node, v_node, weight]					)






      def 			UpperCAmelCase_       (		self:			Dict	,    __lowerCamelCase:			int					):
          '''simple docstring'''


          if self.m_component[u_node] == u_node:
              return u_node
          return self.find_component(self.m_component[u_node]					)






      def 			UpperCAmelCase_       (		self:			str	,    __lowerCamelCase:			int					):
          '''simple docstring'''


          if self.m_component[u_node] != u_node:
              for k in self.m_component:
                  UpperCamelCase__:	Dict					=     self.find_component(__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			str	,    __lowerCamelCase:			list[int]	,    __lowerCamelCase:			int	,    __lowerCamelCase:			int					):
          '''simple docstring'''


          if component_size[u_node] <= component_size[v_node]:
              UpperCamelCase__:	List[str]					=     v_node
              component_size[v_node] += component_size[u_node]
              self.set_component(__lowerCamelCase					)

          elif component_size[u_node] >= component_size[v_node]:
              UpperCamelCase__:	Any					=     self.find_component(__lowerCamelCase					)
              component_size[u_node] += component_size[v_node]
              self.set_component(__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Tuple					):
          '''simple docstring'''


          UpperCamelCase__:	Optional[int]					=     []
          UpperCamelCase__:	Optional[int]					=     0

          UpperCamelCase__:	list[Any]					=     [-1] * self.m_num_of_nodes

          # A list of components (initialized to all of the nodes)
          for node in range(self.m_num_of_nodes					):
              self.m_component.update({node: node}					)
              component_size.append(1					)

          UpperCamelCase__:	Optional[int]					=     self.m_num_of_nodes

          while num_of_components > 1:
              for edge in self.m_edges:
                  UpperCamelCase__				, UpperCamelCase__				, UpperCamelCase__:	List[str]					=     edge

                  UpperCamelCase__:	List[Any]					=     self.m_component[u]
                  UpperCamelCase__:	Tuple					=     self.m_component[v]

                  if u_component != v_component:

                      for component in (u_component, v_component):
                          if (
                              minimum_weight_edge[component] == -1
                              or minimum_weight_edge[component][2] > w
                          ):
                              UpperCamelCase__:	Any					=     [u, v, w]

              for edge in minimum_weight_edge:
                  if isinstance(__lowerCamelCase	,    __lowerCamelCase					):
                      UpperCamelCase__				, UpperCamelCase__				, UpperCamelCase__:	List[str]					=     edge

                      UpperCamelCase__:	Tuple					=     self.m_component[u]
                      UpperCamelCase__:	Optional[Any]					=     self.m_component[v]

                      if u_component != v_component:
                          mst_weight += w
                          self.union(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase					)
                          print(F"Added edge [{u} - {v}]\nAdded weight: {w}\n"					)
                          num_of_components -= 1

              UpperCamelCase__:	List[Any]					=     [-1] * self.m_num_of_nodes
          print(F"The total weight of the minimal spanning tree is: {mst_weight}"					)



def 				lowerCAmelCase_ (							):
    pass


if __name__ == "__main__":
   import doctest

   doctest.testmod()

