





"""simple docstring"""
import json
import os
import shutil
import tempfile
import unittest

from transformers.models.wavaveca import WavaVecaCTCTokenizer, WavaVecaFeatureExtractor, WavaVecaProcessor
from transformers.models.wavaveca.tokenization_wavaveca import VOCAB_FILES_NAMES
from transformers.utils import FEATURE_EXTRACTOR_NAME

from .test_feature_extraction_wavaveca import floats_list







class 	a				(					unittest.TestCase   ):



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      '<pad> <s> </s> <unk> | E T A O N I H S R D L U M W C F G Y P B V K \' X J Q Z'.split(' '			)
  lowerCAmelCase  							=      dict(zip(_snake_case							,    range(len(_snake_case			)			)			)			)

  lowerCAmelCase  							=      {
      'pad_token': '<pad>',
      'unk_token': '<unk>',
      'bos_token': '<s>',
      'eos_token': '</s>',
  }
  lowerCAmelCase  							=      {
      'feature_size': 1,
      'padding_value': 0.0,
      'sampling_rate': 1_60_00,
      'return_attention_mask': False,
      'do_normalize': True,
  }

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

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



 def 					UpperCamelCase__   (			self							,    **_snake_case			):







  """simple docstring"""






  lowerCAmelCase  							=      self.add_kwargs_tokens_map.copy()
  kwargs.update(_snake_case			)
  return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname							,    **_snake_case			)



 def 					UpperCamelCase__   (			self							,    **_snake_case			):







  """simple docstring"""






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



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  shutil.rmtree(self.tmpdirname			)



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      self.get_tokenizer()
  lowerCAmelCase  							=      self.get_feature_extractor()

  lowerCAmelCase  							=      WavaVecaProcessor(tokenizer=_snake_case							,    feature_extractor=_snake_case			)

  processor.save_pretrained(self.tmpdirname			)
  lowerCAmelCase  							=      WavaVecaProcessor.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 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      WavaVecaProcessor(tokenizer=self.get_tokenizer()							,    feature_extractor=self.get_feature_extractor()			)
  processor.save_pretrained(self.tmpdirname			)

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

  lowerCAmelCase  							=      WavaVecaProcessor.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 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      self.get_feature_extractor()
  lowerCAmelCase  							=      self.get_tokenizer()

  lowerCAmelCase  							=      WavaVecaProcessor(tokenizer=_snake_case							,    feature_extractor=_snake_case			)

  lowerCAmelCase  							=      floats_list((3, 10_00)			)

  lowerCAmelCase  							=      feature_extractor(_snake_case							,    return_tensors='np'			)
  lowerCAmelCase  							=      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 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      self.get_feature_extractor()
  lowerCAmelCase  							=      self.get_tokenizer()

  lowerCAmelCase  							=      WavaVecaProcessor(tokenizer=_snake_case							,    feature_extractor=_snake_case			)

  lowerCAmelCase  							=      'This is a test string'

  lowerCAmelCase  							=      processor(text=_snake_case			)

  lowerCAmelCase  							=      tokenizer(_snake_case			)

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



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      self.get_feature_extractor()
  lowerCAmelCase  							=      self.get_tokenizer()

  lowerCAmelCase  							=      WavaVecaProcessor(tokenizer=_snake_case							,    feature_extractor=_snake_case			)

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

  lowerCAmelCase  							=      processor.batch_decode(_snake_case			)
  lowerCAmelCase  							=      tokenizer.batch_decode(_snake_case			)

  self.assertListEqual(_snake_case							,    _snake_case			)



 def 					UpperCamelCase__   (			self			):







  """simple docstring"""






  lowerCAmelCase  							=      self.get_feature_extractor()
  lowerCAmelCase  							=      self.get_tokenizer()

  lowerCAmelCase  							=      WavaVecaProcessor(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'							,    )












"""simple docstring"""
__UpperCamelCase			:		Tuple		    =   10**8

def 						_SCREAMING_SNAKE_CASE       (_UpperCAmelCase :  int       ):
 if n % 10 == 0:
  return False
 lowerCAmelCase  							=      str(_UpperCAmelCase       )
 return s == s[::-1]

def 						_SCREAMING_SNAKE_CASE       ():
 lowerCAmelCase  							=      set()
 lowerCAmelCase  							=      1
 lowerCAmelCase  							=      5
 while sum_squares < LIMIT:
  lowerCAmelCase  							=      first_square + 1
  while sum_squares < LIMIT:
   if is_palindrome(_UpperCAmelCase       ):
    answer.add(_UpperCAmelCase       )
   last_square += 1
   sum_squares += last_square**2
  first_square += 1
  lowerCAmelCase  							=      first_square**2 + (first_square + 1) ** 2

 return sum(_UpperCAmelCase       )


if __name__ == "__main__":
       print(solution())





