




import shutil
import tempfile
import unittest
from pathlib import Path
from shutil import copyfile

from transformers import SpeechaTextTokenizer, is_speech_available
from transformers.models.speech_to_text.tokenization_speech_to_text import VOCAB_FILES_NAMES, save_json
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, require_torchaudio
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_speech_to_text import floats_list


if is_speech_available():
 from transformers import SpeechaTextFeatureExtractor, SpeechaTextProcessor


a_      						=   get_tests_dir("fixtures/test_sentencepiece.model")

@require_torch
@require_torchaudio
@require_sentencepiece
class        _lowerCamelCase  (	unittest.TestCase      ):

      """simple docstring"""

      def 					snake_case		(   self    :       List[str] ):
          __UpperCamelCase     						=  tempfile.mkdtemp()

          __UpperCamelCase     						=  ['''<s>''', '''<pad>''', '''</s>''', '''<unk>''', '''▁This''', '''▁is''', '''▁a''', '''▁t''', '''est''']
          __UpperCamelCase     						=  dict(zip(snake_case       ,				range(len(snake_case ) ) ) )
          __UpperCamelCase     						=  Path(self.tmpdirname )
          save_json(snake_case       ,				save_dir / VOCAB_FILES_NAMES['''vocab_file'''] )
          if not (save_dir / VOCAB_FILES_NAMES["spm_file"]).exists():
              copyfile(snake_case       ,				save_dir / VOCAB_FILES_NAMES['''spm_file'''] )

          __UpperCamelCase     						=  SpeechaTextTokenizer.from_pretrained(self.tmpdirname )
          tokenizer.save_pretrained(self.tmpdirname )

          __UpperCamelCase     						=  {
              '''feature_size''': 24,
              '''num_mel_bins''': 24,
              '''padding_value''': 0.0,
              '''sampling_rate''': 16000,
              '''return_attention_mask''': False,
              '''do_normalize''': True,
          }
          save_json(snake_case       ,				save_dir / FEATURE_EXTRACTOR_NAME )







      def 					snake_case		(   self    :       List[Any]       ,				**snake_case    :       Any ):
          return SpeechaTextTokenizer.from_pretrained(self.tmpdirname       ,				**snake_case )







      def 					snake_case		(   self    :       Any       ,				**snake_case    :       Tuple ):
          return SpeechaTextFeatureExtractor.from_pretrained(self.tmpdirname       ,				**snake_case )







      def 					snake_case		(   self    :       Optional[int] ):
          shutil.rmtree(self.tmpdirname )







      def 					snake_case		(   self    :       Union[str, Any] ):
          __UpperCamelCase     						=  self.get_tokenizer()
          __UpperCamelCase     						=  self.get_feature_extractor()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          processor.save_pretrained(self.tmpdirname )
          __UpperCamelCase     						=  SpeechaTextProcessor.from_pretrained(self.tmpdirname )

          self.assertEqual(processor.tokenizer.get_vocab()       ,				tokenizer.get_vocab() )
          self.assertIsInstance(processor.tokenizer       ,				snake_case )

          self.assertEqual(processor.feature_extractor.to_json_string()       ,				feature_extractor.to_json_string() )
          self.assertIsInstance(processor.feature_extractor       ,				snake_case )







      def 					snake_case		(   self    :       Dict ):
          __UpperCamelCase     						=  SpeechaTextProcessor(
              tokenizer=self.get_tokenizer()       ,				feature_extractor=self.get_feature_extractor() )
          processor.save_pretrained(self.tmpdirname )

          __UpperCamelCase     						=  self.get_tokenizer(bos_token='''(BOS)'''       ,				eos_token='''(EOS)''' )
          __UpperCamelCase     						=  self.get_feature_extractor(do_normalize=snake_case       ,				padding_value=1.0 )

          __UpperCamelCase     						=  SpeechaTextProcessor.from_pretrained(
              self.tmpdirname       ,				bos_token='''(BOS)'''       ,				eos_token='''(EOS)'''       ,				do_normalize=snake_case       ,				padding_value=1.0 )

          self.assertEqual(processor.tokenizer.get_vocab()       ,				tokenizer_add_kwargs.get_vocab() )
          self.assertIsInstance(processor.tokenizer       ,				snake_case )

          self.assertEqual(processor.feature_extractor.to_json_string()       ,				feature_extractor_add_kwargs.to_json_string() )
          self.assertIsInstance(processor.feature_extractor       ,				snake_case )







      def 					snake_case		(   self    :       Any ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  floats_list((3, 1000) )

          __UpperCamelCase     						=  feature_extractor(snake_case       ,				return_tensors='''np''' )
          __UpperCamelCase     						=  processor(snake_case       ,				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 					snake_case		(   self    :       Optional[int] ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  '''This is a test string'''

          __UpperCamelCase     						=  processor(text=snake_case )

          __UpperCamelCase     						=  tokenizer(snake_case )

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







      def 					snake_case		(   self    :       Tuple ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

          __UpperCamelCase     						=  [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

          __UpperCamelCase     						=  processor.batch_decode(snake_case )
          __UpperCamelCase     						=  tokenizer.batch_decode(snake_case )

          self.assertListEqual(snake_case       ,				snake_case )







      def 					snake_case		(   self    :       List[str] ):
          __UpperCamelCase     						=  self.get_feature_extractor()
          __UpperCamelCase     						=  self.get_tokenizer()

          __UpperCamelCase     						=  SpeechaTextProcessor(tokenizer=snake_case       ,				feature_extractor=snake_case )

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









from __future__ import annotations

from queue import Queue




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )->		tuple[int, int]:



    """simple docstring"""






    a ^= b
    b ^= a
    a ^= b
    return a, b




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )->		list[list[int]]:



    """simple docstring"""






    UpperCamelCase_          =		1
    while (1 << j) < max_node:
        for i in range(1       ,		max_node + 1       ):
            UpperCamelCase_          =		parent[j - 1][parent[j - 1][i]]
        j += 1
    return parent




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )->		int:



    """simple docstring"""






    if level[u] < level[v]:
        UpperCamelCase_   ,    UpperCamelCase_          =		swap(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )
    # making depth of u same as depth of v
    for i in range(1_8       ,		-1       ,		-1       ):
        if level[u] - (1 << i) >= level[v]:
            UpperCamelCase_          =		parent[i][u]
    # at the same depth if u==v that mean lca is found
    if u == v:
        return u
    # moving both nodes upwards till lca in found
    for i in range(1_8       ,		-1       ,		-1       ):
        if parent[i][u] not in [0, parent[i][v]]:
            UpperCamelCase_   ,    UpperCamelCase_          =		parent[i][u], parent[i][v]
    # returning longest common ancestor of u,v
    return parent[0][u]




def        lowerCAmelCase(	SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_ = 1       ,		)->		tuple[list[int], list[list[int]]]:



    """simple docstring"""






    UpperCamelCase_          =		0
    UpperCamelCase_          =		Queue(maxsize=SCREAMING_SNAKE_CASE_       )
    q.put(SCREAMING_SNAKE_CASE_       )
    while q.qsize() != 0:
        UpperCamelCase_          =		q.get()
        for v in graph[u]:
            if level[v] == -1:
                UpperCamelCase_          =		level[u] + 1
                q.put(SCREAMING_SNAKE_CASE_       )
                UpperCamelCase_          =		u
    return level, parent




def        lowerCAmelCase(	)->		None:



    """simple docstring"""






    UpperCamelCase_          =		1_3
    # initializing with 0
    UpperCamelCase_          =		[[0 for _ in range(max_node + 1_0       )] for _ in range(2_0       )]
    # initializing with -1 which means every node is unvisited
    UpperCamelCase_          =		[-1 for _ in range(max_node + 1_0       )]
    UpperCamelCase_          =		{
        1: [2, 3, 4],
        2: [5],
        3: [6, 7],
        4: [8],
        5: [9, 1_0],
        6: [1_1],
        7: [],
        8: [1_2, 1_3],
        9: [],
        1_0: [],
        1_1: [],
        1_2: [],
        1_3: [],
    }
    UpperCamelCase_   ,    UpperCamelCase_          =		breadth_first_search(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       ,		1       )
    UpperCamelCase_          =		create_sparse(SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )
    print("LCA of node 1 and 3 is: "       ,		lowest_common_ancestor(1       ,		3       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )
    print("LCA of node 5 and 6 is: "       ,		lowest_common_ancestor(5       ,		6       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )
    print("LCA of node 7 and 11 is: "       ,		lowest_common_ancestor(7       ,		1_1       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )
    print("LCA of node 6 and 7 is: "       ,		lowest_common_ancestor(6       ,		7       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )
    print("LCA of node 4 and 12 is: "       ,		lowest_common_ancestor(4       ,		1_2       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )
    print("LCA of node 8 and 8 is: "       ,		lowest_common_ancestor(8       ,		8       ,		SCREAMING_SNAKE_CASE_       ,		SCREAMING_SNAKE_CASE_       )       )


if __name__ == "__main__":
 main()
