





'''simple docstring'''







import json
import os
import unittest
from typing import Tuple

from transformers import WavaVecaPhonemeCTCTokenizer
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.models.wavaveca_phoneme.tokenization_wavaveca_phoneme import WavaVecaPhonemeCTCTokenizerOutput
from transformers.testing_utils import require_phonemizer

from ...test_tokenization_common import TokenizerTesterMixin
@require_phonemizer
class       _lowercase    (							SCREAMING_SNAKE_CASE_					,		unittest.TestCase       ):
     _UpperCAmelCase					    =       WavaVecaPhonemeCTCTokenizer
     _UpperCAmelCase					    =       False







     def      UpperCamelCase      (			self     )			->						Optional[Any]:
      super().setUp()

      snake_case					=      (
          '<s> <pad> </s> <unk> n s t ə l a i k d m ɛ ɾ e ɪ p o ɐ z ð f j v b ɹ ʁ ʊ iː r w ʌ u ɡ æ aɪ ʃ h ɔ ɑː '
          'ŋ ɚ eɪ β uː y ɑ̃ oʊ ᵻ eː θ aʊ ts oː ɔ̃ ɣ ɜ ɑ dʒ əl x ɜː ç ʒ tʃ ɔː ɑːɹ ɛ̃ ʎ ɔːɹ ʋ aː ɕ œ ø oːɹ ɲ yː '
          'ʔ iə i5 s. tɕ ?? nʲ ɛː œ̃ ɭ ɔø ʑ tʲ ɨ ɛɹ ts. rʲ ɪɹ ɭʲ i.5 ɔɪ q sʲ u5 ʊɹ iɜ a5 iɛ5 øː ʕ ja əɜ th ɑ5 '
          'oɪ dʲ ə5 tɕh ts.h mʲ ɯ dʑ vʲ e̞ tʃʲ ei5 o5 onɡ5 ɑu5 iɑ5 ai5 aɪɚ kh ə1 ʐ i2 ʉ ħ t[ aɪə ʲ ju ə2 u2 oɜ '
          'pː iɛɜ ou5 y5 uɜ tː uo5 d[ uoɜ tsh ɑɜ ɵ i̪5 uei5 ɟ aɜ ɑɨ i.ɜ eʊ o2 ɐ̃ ä pʲ kʲ n̩ ɒ ph ɑu2 uɨ əɪ ɫ ɬ '
          'yɜ bʲ ɑ2 s̪ aiɜ χ ɐ̃ʊ̃ 1 ə4 yæɜ a2 ɨː t̪ iouɜ ũ onɡɜ aɨ iɛ2 ɔɨ ɑuɜ o̞ ei2 iou2 c kː y2 ɖ oe dˤ yɛɜ '
          'əʊ S ɡʲ onɡ2 u" eiɜ ʈ ɯᵝ iou5 dZ r̝̊ i.2 tS s^ ʝ yə5 iɑɜ uə5 pf ɨu iɑ2 ou2 ər2 fʲ ai2 r̝ uəɜ ɳ əɨ '
          'ua5 uɪ ɽ bː yu5 uo2 yɛ5 l̩ ɻ ərɜ ʂ i̪2 ouɜ uaɜ a. a.ː yæ5 dː r̩ ee ɪu ər5 i̪ ɜ æi u: i.ː t^ o1 ɪ^ '
          'ai ueiɜ æː ɛɪ eə i. ɴ ie ua2 ɑ1 o4 tʃː o: ɑ: u1 N i̪1 au yæ2 u. qː yəɜ y: kʰ tʃʰ iʊ sx õ uo tʰ '
          'uai5 bʰ u.ː uə2 ʊə d^ s̪ː yiɜ dʰ r. oe: i1 ɟː yu2 nʲʲ i̪4 uei2 tsʲ ɸ ĩ ɑ4 t̪ː eɑ u4 e: tsː ʈʰ ɡʰ '
          'ɯɯ dʒʲ ʂʲ X ɵː uaiɜ tɕʲ ã t^ː ẽː yɛ2 cː i.1 ɛʊ dˤdˤ dʒː i4 ɡː yi ɕʲ ɟʰ pʰ dʑʲ yuɜ ua1 ua4 æiː ɐɐ '
          'ui iou1 ʊː a1 iou4 cʰ iɛ1 yə2 ɖʰ ẽ ʒʲ ää ər4 iːː ɪː iɑ1 ər1 œː øi ɪuː cʰcʰ əː1 iː1 ũ kʰː o̞o̞ xʲ '
          'ou1 iɛ4 e̞e̞ y1 dzː dʲʲ dʰː ɯᵝɯᵝ lː uo1 i.4 i: yɛ5ʲ a4'
      ).split(''' '''     )
      snake_case					=      dict(zip(snake_case__     , range(len(snake_case__     )     )     )     )

      snake_case					=      {'pad_token': '<pad>', 'unk_token': '<unk>', 'bos_token': '<s>', 'eos_token': '</s>'}

      snake_case					=      os.path.join(self.tmpdirname     , VOCAB_FILES_NAMES['''vocab_file''']     )
      with open(self.vocab_file     , '''w'''     , encoding='''utf-8'''     ) as fp:
       fp.write(json.dumps(snake_case__     ) + '''\n'''     )







     def      UpperCamelCase      (			self     , A__     , A__=False     , A__=20     , A__=5     )			->						List[Any]:
      snake_case					=      [(i, tokenizer.decode([i]     , clean_up_tokenization_spaces=snake_case__     )) for i in range(len(snake_case__     )     )]
      snake_case					=      list(filter(lambda A__     : [t[0]] == tokenizer.encode(t[1]     , do_phonemize=snake_case__     )     , snake_case__     )     )
      if max_length is not None and len(snake_case__     ) > max_length:
       snake_case					=      toks[:max_length]
      if min_length is not None and len(snake_case__     ) < min_length and len(snake_case__     ) > 0:
       while len(snake_case__     ) < min_length:
        snake_case					=      toks + toks
        # toks_str = [t[1] for t in toks]
      snake_case					=      [t[0] for t in toks]

      # Ensure consistency
      snake_case					=      tokenizer.decode(snake_case__     , clean_up_tokenization_spaces=snake_case__     )
      if " " not in output_txt and len(snake_case__     ) > 1:
       snake_case					=      (
           tokenizer.decode([toks_ids[0]]     , clean_up_tokenization_spaces=snake_case__     )
           + ' '
           + tokenizer.decode(toks_ids[1:]     , clean_up_tokenization_spaces=snake_case__     )
       )
      if with_prefix_space:
       snake_case					=      ' ' + output_txt
      snake_case					=      tokenizer.encode(snake_case__     , add_special_tokens=snake_case__     )
      return output_txt, output_ids







     def      UpperCamelCase      (			self     , **A__     )			->						List[Any]:
      kwargs.update(self.special_tokens_map     )
      return WavaVecaPhonemeCTCTokenizer.from_pretrained(self.tmpdirname     , **snake_case__     )







     def      UpperCamelCase      (			self     )			->						List[Any]:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )

      # check adding a single token
      tokenizer.add_tokens('''xxx'''     )
      snake_case					=      tokenizer('''m xxx ɪ'''     , do_phonemize=snake_case__     ).input_ids
      self.assertEqual(snake_case__     , [13, 3_92, 17]     )  # xxx should be last token

      tokenizer.add_tokens(['''aaa''', '''bbb''', '''ccc''']     )
      snake_case					=      tokenizer('''m aaa ɪ ccc'''     , do_phonemize=snake_case__     ).input_ids
      self.assertEqual(snake_case__     , [13, 3_93, 17, 3_95]     )  # aaa and ccc should be after xxx and 2 after aaa

      snake_case					=      tokenizer('''maɪ c'''     , do_phonemize=snake_case__     ).input_ids
      self.assertEqual(snake_case__     , [3, 2_00]     )  # mai should be <unk> (=3)







     def      UpperCamelCase      (			self     )			->						Dict:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )
      self.assertEqual(snake_case__     , '''h ə l oʊ h aʊ ɑːɹ j uː'''     )







     def      UpperCamelCase      (			self     )			->						List[Any]:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )
      self.assertEqual(tokenizer(snake_case__     ).input_ids     , tokenizer(snake_case__     , do_phonemize=snake_case__     ).input_ids     )







     def      UpperCamelCase      (			self     )			->						Tuple:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )
      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )

      snake_case					=      tokenizer.decode(tokenizer(snake_case__     ).input_ids     )

      self.assertEqual(snake_case__     , snake_case__     )







     def      UpperCamelCase      (			self     )			->						List[str]:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )

      snake_case					=      [
          [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98],
          [24, 22, 5, 24, 22, 5, 77],
      ]
      snake_case					=      tokenizer.decode(sample_ids[0]     )
      snake_case					=      tokenizer.batch_decode(snake_case__     )
      self.assertEqual(snake_case__     , batch_tokens[0]     )
      self.assertEqual(snake_case__     , ['''k s ɾ ɾ l ɭʲ''', '''j ð s j ð s oːɹ''']     )







     def      UpperCamelCase      (			self     )			->						Tuple:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )
      self.assertEqual(snake_case__     , '''h ə l oʊ | h aʊ | ɑːɹ | j uː |'''     )







     def      UpperCamelCase      (			self     )			->						str:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )
      self.assertEqual(tokenizer(snake_case__     ).input_ids     , tokenizer(snake_case__     , do_phonemize=snake_case__     ).input_ids     )







     def      UpperCamelCase      (			self     )			->						Any:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      # fmt: off
      snake_case					=      [
          [11, 5, 15, tokenizer.pad_token_id, tokenizer.word_delimiter_token_id, 15, 8, tokenizer.word_delimiter_token_id, 98],
          [tokenizer.word_delimiter_token_id, 24, 22, tokenizer.word_delimiter_token_id, 5, 24, 22, 5, 77],
      ]
      # fmt: on

      # decode with word_del_token filter
      snake_case					=      tokenizer.decode(sample_ids[0]     )
      snake_case					=      tokenizer.batch_decode(snake_case__     )
      self.assertEqual(snake_case__     , batch_tokens[0]     )
      self.assertEqual(snake_case__     , ['''k s ɾ ɾ l ɭʲ''', '''j ð s j ð s oːɹ''']     )

      # decode with no word_del_token filter
      snake_case					=      tokenizer.decode(sample_ids[0]     , filter_word_delimiter_token=snake_case__     )
      snake_case					=      tokenizer.batch_decode(snake_case__     , filter_word_delimiter_token=snake_case__     )
      self.assertEqual(snake_case__     , batch_tokens[0]     )
      self.assertEqual(snake_case__     , ['''k s ɾ | ɾ l | ɭʲ''', '''| j ð | s j ð s oːɹ''']     )







     def      UpperCamelCase      (			self     )			->						Optional[int]:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )

      snake_case					=      tokenizer.decode(tokenizer(snake_case__     ).input_ids     , filter_word_delimiter_token=snake_case__     )

      self.assertEqual(snake_case__     , snake_case__     )







     def      UpperCamelCase      (			self     )			->						Dict:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      snake_case					=      'Hello how are you'
      snake_case					=      tokenizer.phonemize(snake_case__     , phonemizer_lang='''en-us'''     )

      snake_case					=      tokenizer.decode(tokenizer(snake_case__     ).input_ids     , filter_word_delimiter_token=snake_case__     )

      self.assertEqual(''' '''.join([p.strip() for p in phonemes.split(''' |'''     )]     ).strip()     , snake_case__     )







     def      UpperCamelCase      (			self     )			->						Tuple:
      snake_case					=      self.tokenizer_class.from_pretrained(
          '''facebook/wav2vec2-lv-60-espeak-cv-ft'''     , word_delimiter_token=snake_case__     )
      snake_case					=      'Hello how are you'

      snake_case					=      tokenizer(snake_case__     , phonemizer_lang='''en-us'''     ).input_ids
      snake_case					=      tokenizer(snake_case__     , phonemizer_lang='''fr-fr'''     ).input_ids

      self.assertNotEqual(snake_case__     , snake_case__     )

      snake_case					=      tokenizer.decode(snake_case__     )
      snake_case					=      tokenizer.decode(snake_case__     )

      self.assertEqual(snake_case__     , '''h ə l oʊ h aʊ ɑːɹ j uː'''     )
      self.assertEqual(snake_case__     , '''ɛ l o h aʊ a ʁ j u'''     )







     def      UpperCamelCase      (			self     )			->						Tuple:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )
      snake_case					=      'Hello how Are you'
      snake_case					=      'hello how are you'

      snake_case					=      tokenizer(snake_case__     ).input_ids
      snake_case					=      tokenizer(snake_case__     ).input_ids

      self.assertEqual(snake_case__     , snake_case__     )







     def      UpperCamelCase      (			self     )			->						Tuple:
      snake_case					=      self.tokenizer_class.from_pretrained('''facebook/wav2vec2-lv-60-espeak-cv-ft'''     )
      tokenizer.add_tokens(['''!''', '''?''']     )
      tokenizer.add_special_tokens({'''cls_token''': '''$$$'''}     )

      # fmt: off
      snake_case					=      [
          [11, 5, 15, tokenizer.pad_token_id, 15, 8, 98, 3_92, 3_92, 3_93, 3_92, 3_92, 3_93, 3_94, 3_94],
          [24, 22, 5, 24, 22, 5, 77, tokenizer.pad_token_id, 3_94, 3_94],
      ]
      # fmt: on

      snake_case					=      tokenizer.batch_decode(snake_case__     )
      self.assertEqual(snake_case__     , ['''k s ɾ ɾ l ɭʲ!?!? $$$''', '''j ð s j ð s oːɹ $$$''']     )







     @staticmethod
     def      UpperCamelCase      (			A__     , A__     )			->						Tuple:
      snake_case					=      [d[key] for d in offsets]
      return retrieved_list







     def      UpperCamelCase      (			self     )			->						str:
      snake_case					=      self.get_tokenizer(word_delimiter_token='''|'''     )
      tokenizer.add_tokens('''|'''     )

      # fmt: off
      # ksssɾɾ|ɾɾ<pad>ɾɾ|<pad>ɾlll|ɭʲ -> k s ɾ ɾ | ɾ l | ɭʲ"
      snake_case					=      [11, 5, 5, 5, 15, 15, tokenizer.pad_token_id, 15, 15, tokenizer.word_delimiter_token_id, tokenizer.pad_token_id, 15, 8, 8, 8, tokenizer.word_delimiter_token_id, 98]
      # fmt: on

      snake_case					=      tokenizer.decode(snake_case__     , output_char_offsets=snake_case__     , filter_word_delimiter_token=snake_case__     )
      # check Wav2Vec2CTCTokenizerOutput keys for char
      self.assertEqual(len(outputs.keys()     )     , 2     )
      self.assertTrue('''text''' in outputs     )
      self.assertTrue('''char_offsets''' in outputs     )
      self.assertTrue(isinstance(snake_case__     , snake_case__     )     )

      # check that order of chars is correct and identical for both outputs
      self.assertEqual(''' '''.join(self.get_from_offsets(outputs['''char_offsets''']     , '''char'''     )     )     , outputs.text     )
      self.assertListEqual(
          self.get_from_offsets(outputs['''char_offsets''']     , '''char'''     )     , ['''k''', '''s''', '''ɾ''', '''ɾ''', '''|''', '''ɾ''', '''l''', '''|''', '''ɭʲ''']     )

      # check that offsets are actually correct for char
      # 0-1 is 11, 1-4 is 5, 4-6 is first 15, 6-7 is <pad> (thus not shown), 7-9 is second 15, 9-10 is word_delimiter_token,
      # 10-11 is <pad> (thus not shown), 11-12 is third 15, 12-15 is 8, 15-16 is word_delimiter_token, 16-17 is 98
      self.assertListEqual(
          self.get_from_offsets(outputs['''char_offsets''']     , '''start_offset'''     )     , [0, 1, 4, 7, 9, 11, 12, 15, 16]     )
      self.assertListEqual(
          self.get_from_offsets(outputs['''char_offsets''']     , '''end_offset'''     )     , [1, 4, 6, 9, 10, 12, 15, 16, 17]     )







     def      UpperCamelCase      (			self     )			->						str:
      snake_case					=      self.get_tokenizer(word_delimiter_token='''|'''     )

      def check_list_tuples_equal(A__     , A__     ):
       self.assertTrue(isinstance(snake_case__     , snake_case__     )     )
       self.assertTrue(isinstance(outputs_list[0]     , snake_case__     )     )

       # transform list to ModelOutput
       snake_case					=      WavaVecaPhonemeCTCTokenizerOutput(
           {k: [d[k] for d in outputs_list] for k in outputs_list[0]}     )

       self.assertListEqual(outputs_batch['''text''']     , outputs_batch_a['''text''']     )

       def recursive_check(A__     , A__     ):
        if isinstance(snake_case__     , snake_case__     ):
         [recursive_check(snake_case__     , snake_case__     ) for la, la in zip(snake_case__     , snake_case__     )]
        self.assertEqual(snake_case__     , snake_case__     )

       if "char_offsets" in outputs_batch:
        recursive_check(outputs_batch['''char_offsets''']     , outputs_batch_a['''char_offsets''']     )

        # fmt: off
      snake_case					=      [
          [11, 5, 15, tokenizer.pad_token_id, 15, 4, 8, 98, 32, 32, 32, 32, 4, 33, tokenizer.word_delimiter_token_id, 32, 32, 33, 34, 34],
          [24, 22, 5, tokenizer.word_delimiter_token_id, tokenizer.word_delimiter_token_id, 24, 22, 22, 22, 4, 5, 77, tokenizer.pad_token_id, 22, 22, 4, 34, 34, 34, 34],
      ]
      # fmt: on

      # We assume that `decode` works as expected. All we will check now is
      # the output type is correct and the output is identical to `decode`

      # char
      snake_case					=      tokenizer.batch_decode(snake_case__     , output_char_offsets=snake_case__     )
      snake_case					=      [tokenizer.decode(snake_case__     , output_char_offsets=snake_case__     ) for ids in sample_ids]
      check_list_tuples_equal(snake_case__     , snake_case__     )







     @unittest.skip('''Wav2Vec2PhonemeTokenizer always lower cases letters to correctly map to phonemes'''     )
     def      UpperCamelCase      (			self     )			->						Dict:
      pass







     @unittest.skip('''Wav2Vec2PhonemeTokenizer always puts spaces between phonemes'''     )
     def      UpperCamelCase      (			self     )			->						Dict:
      pass







     @unittest.skip('''encodes to text to ids, but decodes ids to phonemes -> not possible to have internal consistency'''     )
     def      UpperCamelCase      (			self     )			->						Optional[int]:
      pass







     @unittest.skip('''Wav2Vec2PhonemeModel has no max model length => no testing'''     )
     def      UpperCamelCase      (			self     )			->						Any:
      pass







     def      UpperCamelCase      (			self     )			->						int:
      snake_case					=      self.get_tokenizers(do_lower_case=snake_case__     )
      for tokenizer in tokenizers:
       with self.subTest(F"""{tokenizer.__class__.__name__}"""     ):
        snake_case					=      tokenizer.vocab_size
        snake_case					=      len(snake_case__     )

        self.assertNotEqual(snake_case__     , 0     )

        # We usually have added tokens from the start in tests because our vocab fixtures are
        # smaller than the original vocabs - let's not assert this
        # self.assertEqual(vocab_size, all_size)

        snake_case					=      ['aaaaa bbbbbb', 'cccccccccdddddddd']
        snake_case					=      tokenizer.add_tokens(snake_case__     )
        snake_case					=      tokenizer.vocab_size
        snake_case					=      len(snake_case__     )

        self.assertNotEqual(snake_case__     , 0     )
        self.assertEqual(snake_case__     , snake_case__     )
        self.assertEqual(snake_case__     , len(snake_case__     )     )
        self.assertEqual(snake_case__     , all_size + len(snake_case__     )     )

        snake_case					=      tokenizer.encode('''aaaaa bbbbbb low cccccccccdddddddd l'''     , add_special_tokens=snake_case__     )

        self.assertGreaterEqual(len(snake_case__     )     , 4     )
        self.assertGreater(tokens[0]     , tokenizer.vocab_size - 1     )
        self.assertGreater(tokens[-3]     , tokenizer.vocab_size - 1     )

        snake_case					=      {'eos_token': '>>>>|||<||<<|<<', 'pad_token': '<<<<<|||>|>>>>|>'}
        snake_case					=      tokenizer.add_special_tokens(snake_case__     )
        snake_case					=      tokenizer.vocab_size
        snake_case					=      len(snake_case__     )

        self.assertNotEqual(snake_case__     , 0     )
        self.assertEqual(snake_case__     , snake_case__     )
        self.assertEqual(snake_case__     , len(snake_case__     )     )
        self.assertEqual(snake_case__     , all_size_a + len(snake_case__     )     )

        snake_case					=      tokenizer.encode(
            '''>>>>|||<||<<|<< aaaaabbbbbb low cccccccccdddddddd <<<<<|||>|>>>>|> l'''     , add_special_tokens=snake_case__     )

        self.assertGreaterEqual(len(snake_case__     )     , 6     )
        self.assertGreater(tokens[0]     , tokenizer.vocab_size - 1     )
        self.assertGreater(tokens[0]     , tokens[1]     )
        self.assertGreater(tokens[-3]     , tokenizer.vocab_size - 1     )
        self.assertGreater(tokens[-3]     , tokens[-4]     )
        self.assertEqual(tokens[0]     , tokenizer.eos_token_id     )
        self.assertEqual(tokens[-3]     , tokenizer.pad_token_id     )







     @unittest.skip('''The tokenizer shouldn\'t be used to encode input IDs (except for labels), only to decode.'''     )
     def      UpperCamelCase      (			self     )			->						Tuple:
      pass







     @unittest.skip('''The tokenizer shouldn\'t be used to encode input IDs (except for labels), only to decode.'''     )
     def      UpperCamelCase      (			self     )			->						Dict:
      pass







     def      UpperCamelCase      (			self     )			->						str:
      snake_case					=      self.get_tokenizers(fast=snake_case__     , do_lower_case=snake_case__     )
      for tokenizer in tokenizers:
       with self.subTest(F"""{tokenizer.__class__.__name__}"""     ):
        snake_case					=      ['ð', 'ɪ', 's', 'ɪ', 'z', 'ɐ', 't', 'ɛ', 'k', 's', 't']
        snake_case					=      tokenizer.convert_tokens_to_string(snake_case__     )

        self.assertIsInstance(output['''text''']     , snake_case__     )





'''simple docstring'''







from math import pi, sqrt, tan






def       lowercase					(_A       ):







       """simple docstring"""







       if side_length < 0:
              raise ValueError('surface_area_cube() only accepts non-negative values'       )
       return 6 * side_length**2






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if length < 0 or breadth < 0 or height < 0:
              raise ValueError('surface_area_cuboid() only accepts non-negative values'       )
       return 2 * ((length * breadth) + (breadth * height) + (length * height))






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('surface_area_sphere() only accepts non-negative values'       )
       return 4 * pi * radius**2






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('surface_area_hemisphere() only accepts non-negative values'       )
       return 3 * pi * radius**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius < 0 or height < 0:
              raise ValueError('surface_area_cone() only accepts non-negative values'       )
       return pi * radius * (radius + (height**2 + radius**2) ** 0.5)






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if radius_a < 0 or radius_a < 0 or height < 0:
              raise ValueError(
                  'surface_area_conical_frustum() only accepts non-negative values'       )
       _lowerCAmelCase     :				int       =							(height**2 + (radius_a - radius_a) ** 2) ** 0.5
       return pi * ((slant_height * (radius_a + radius_a)) + radius_a**2 + radius_a**2)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius < 0 or height < 0:
              raise ValueError('surface_area_cylinder() only accepts non-negative values'       )
       return 2 * pi * radius * (height + radius)






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if torus_radius < 0 or tube_radius < 0:
              raise ValueError('surface_area_torus() only accepts non-negative values'       )
       if torus_radius < tube_radius:
              raise ValueError(
                  'surface_area_torus() does not support spindle or self intersecting tori'       )
       return 4 * pow(_A ,    2       ) * torus_radius * tube_radius






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if length < 0 or width < 0:
              raise ValueError('area_rectangle() only accepts non-negative values'       )
       return length * width






def       lowercase					(_A       ):







       """simple docstring"""







       if side_length < 0:
              raise ValueError('area_square() only accepts non-negative values'       )
       return side_length**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if base < 0 or height < 0:
              raise ValueError('area_triangle() only accepts non-negative values'       )
       return (base * height) / 2






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if sidea < 0 or sidea < 0 or sidea < 0:
              raise ValueError('area_triangle_three_sides() only accepts non-negative values'       )
       elif sidea + sidea < sidea or sidea + sidea < sidea or sidea + sidea < sidea:
              raise ValueError('Given three sides do not form a triangle'       )
       _lowerCAmelCase     :				Tuple       =							(sidea + sidea + sidea) / 2
       _lowerCAmelCase     :				Dict       =							sqrt(
           semi_perimeter
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)
           * (semi_perimeter - sidea)       )
       return area






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if base < 0 or height < 0:
              raise ValueError('area_parallelogram() only accepts non-negative values'       )
       return base * height






def       lowercase					(_A ,    _A ,    _A       ):







       """simple docstring"""







       if basea < 0 or basea < 0 or height < 0:
              raise ValueError('area_trapezium() only accepts non-negative values'       )
       return 1 / 2 * (basea + basea) * height






def       lowercase					(_A       ):







       """simple docstring"""







       if radius < 0:
              raise ValueError('area_circle() only accepts non-negative values'       )
       return pi * radius**2






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if radius_x < 0 or radius_y < 0:
              raise ValueError('area_ellipse() only accepts non-negative values'       )
       return pi * radius_x * radius_y






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if diagonal_a < 0 or diagonal_a < 0:
              raise ValueError('area_rhombus() only accepts non-negative values'       )
       return 1 / 2 * diagonal_a * diagonal_a






def       lowercase					(_A ,    _A       ):







       """simple docstring"""







       if not isinstance(_A ,    _A       ) or sides < 3:
              raise ValueError(
                  'area_reg_polygon() only accepts integers greater than or \
equal to three as number of sides'       )
       elif length < 0:
              raise ValueError(
                  'area_reg_polygon() only accepts non-negative values as \
length of a side'       )
       return (sides * length**2) / (4 * tan(pi / sides       ))
       return (sides * length**2) / (4 * tan(pi / sides       ))


if __name__ == "__main__":
       import doctest

       doctest.testmod(verbose=True)  # verbose so we can see methods missing tests

       print("""[DEMO] Areas of various geometric shapes: \n""")
       print(F'''Rectangle: {area_rectangle(10, 20) = }''')
       print(F'''Square: {area_square(10) = }''')
       print(F'''Triangle: {area_triangle(10, 10) = }''')
       print(F'''Triangle: {area_triangle_three_sides(5, 12, 13) = }''')
       print(F'''Parallelogram: {area_parallelogram(10, 20) = }''')
       print(F'''Rhombus: {area_rhombus(10, 20) = }''')
       print(F'''Trapezium: {area_trapezium(10, 20, 30) = }''')
       print(F'''Circle: {area_circle(20) = }''')
       print(F'''Ellipse: {area_ellipse(10, 20) = }''')
       print("""\nSurface Areas of various geometric shapes: \n""")
       print(F'''Cube: {surface_area_cube(20) = }''')
       print(F'''Cuboid: {surface_area_cuboid(10, 20, 30) = }''')
       print(F'''Sphere: {surface_area_sphere(20) = }''')
       print(F'''Hemisphere: {surface_area_hemisphere(20) = }''')
       print(F'''Cone: {surface_area_cone(10, 20) = }''')
       print(F'''Conical Frustum: {surface_area_conical_frustum(10, 20, 30) = }''')
       print(F'''Cylinder: {surface_area_cylinder(10, 20) = }''')
       print(F'''Torus: {surface_area_torus(20, 10) = }''')
       print(F'''Equilateral Triangle: {area_reg_polygon(3, 10) = }''')
       print(F'''Square: {area_reg_polygon(4, 10) = }''')
       print(F'''Reqular Pentagon: {area_reg_polygon(5, 10) = }''')

