


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





		"""simple docstring"""




		def   snake_case		(   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(UpperCamelCase      ,  range(len(UpperCamelCase					)					)					)					)

			lowerCamelCase_								=  {
			    "pad_token": "<pad>",
			    "unk_token": "<unk>",
			    "bos_token": "<s>",
			    "eos_token": "</s>",
			}
			lowerCamelCase_								=  {
			    "feature_size": 1,
			    "padding_value": 0.0,
			    "sampling_rate": 1_6000,
			    "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      ,  UpperCamelCase					)
			with open(self.vocab_file      ,  "w"      ,  encoding="utf-8"					) as fp:
				fp.write(json.dumps(UpperCamelCase					) + "\n"					)

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






		def   snake_case		(   self      ,  **UpperCamelCase					):







			"""simple docstring"""
			lowerCamelCase_								=  self.add_kwargs_tokens_map.copy()
			kwargs.update(UpperCamelCase					)
			return WavaVecaCTCTokenizer.from_pretrained(self.tmpdirname      ,  **UpperCamelCase					)






		def   snake_case		(   self      ,  **UpperCamelCase					):







			"""simple docstring"""
			return WavaVecaFeatureExtractor.from_pretrained(self.tmpdirname      ,  **UpperCamelCase					)






		def   snake_case		(   self					):







			"""simple docstring"""
			shutil.rmtree(self.tmpdirname					)






		def   snake_case		(   self					):







			"""simple docstring"""
			lowerCamelCase_								=  self.get_tokenizer()
			lowerCamelCase_								=  self.get_feature_extractor()

			lowerCamelCase_								=  WavaVecaProcessor(tokenizer=UpperCamelCase      ,  feature_extractor=UpperCamelCase					)

			processor.save_pretrained(self.tmpdirname					)
			lowerCamelCase_								=  WavaVecaProcessor.from_pretrained(self.tmpdirname					)

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

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






		def   snake_case		(   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=UpperCamelCase      ,  padding_value=1.0					)

			lowerCamelCase_								=  WavaVecaProcessor.from_pretrained(
			    self.tmpdirname      ,  bos_token="(BOS)"      ,  eos_token="(EOS)"      ,  do_normalize=UpperCamelCase      ,  padding_value=1.0					)

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

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






		def   snake_case		(   self					):







			"""simple docstring"""
			lowerCamelCase_								=  self.get_feature_extractor()
			lowerCamelCase_								=  self.get_tokenizer()

			lowerCamelCase_								=  WavaVecaProcessor(tokenizer=UpperCamelCase      ,  feature_extractor=UpperCamelCase					)

			lowerCamelCase_								=  floats_list((3, 1000)					)

			lowerCamelCase_								=  feature_extractor(UpperCamelCase      ,  return_tensors="np"					)
			lowerCamelCase_								=  processor(UpperCamelCase      ,  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					):







			"""simple docstring"""
			lowerCamelCase_								=  self.get_feature_extractor()
			lowerCamelCase_								=  self.get_tokenizer()

			lowerCamelCase_								=  WavaVecaProcessor(tokenizer=UpperCamelCase      ,  feature_extractor=UpperCamelCase					)

			lowerCamelCase_								=  "This is a test string"

			lowerCamelCase_								=  processor(text=UpperCamelCase					)

			lowerCamelCase_								=  tokenizer(UpperCamelCase					)

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






		def   snake_case		(   self					):







			"""simple docstring"""
			lowerCamelCase_								=  self.get_feature_extractor()
			lowerCamelCase_								=  self.get_tokenizer()

			lowerCamelCase_								=  WavaVecaProcessor(tokenizer=UpperCamelCase      ,  feature_extractor=UpperCamelCase					)

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

			lowerCamelCase_								=  processor.batch_decode(UpperCamelCase					)
			lowerCamelCase_								=  tokenizer.batch_decode(UpperCamelCase					)

			self.assertListEqual(UpperCamelCase      ,  UpperCamelCase					)







		def   snake_case		(   self					):







			"""simple docstring"""
			lowerCamelCase_								=  self.get_feature_extractor()
			lowerCamelCase_								=  self.get_tokenizer()

			lowerCamelCase_								=  WavaVecaProcessor(tokenizer=UpperCamelCase      ,  feature_extractor=UpperCamelCase					)

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







'''simple docstring'''

from collections import OrderedDict
from typing import Mapping

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


a_  :    Optional[Any]      =			logging.get_logger(__name__)

a_  :    Tuple      =			{
    """google/electra-small-generator""": """https://huggingface.co/google/electra-small-generator/resolve/main/config.json""",
    """google/electra-base-generator""": """https://huggingface.co/google/electra-base-generator/resolve/main/config.json""",
    """google/electra-large-generator""": """https://huggingface.co/google/electra-large-generator/resolve/main/config.json""",
    """google/electra-small-discriminator""": (
        """https://huggingface.co/google/electra-small-discriminator/resolve/main/config.json"""
    ),
    """google/electra-base-discriminator""": (
        """https://huggingface.co/google/electra-base-discriminator/resolve/main/config.json"""
    ),
    """google/electra-large-discriminator""": (
        """https://huggingface.co/google/electra-large-discriminator/resolve/main/config.json"""
    ),
}





class 					snake_case   (   lowercase      ):





  """simple docstring"""




  _lowerCamelCase		   =  "electra"






  def __init__(   self      ,  UpperCamelCase=3_0522      ,  UpperCamelCase=128      ,  UpperCamelCase=256      ,  UpperCamelCase=12      ,  UpperCamelCase=4      ,  UpperCamelCase=1024      ,  UpperCamelCase="gelu"      ,  UpperCamelCase=0.1      ,  UpperCamelCase=0.1      ,  UpperCamelCase=512      ,  UpperCamelCase=2      ,  UpperCamelCase=0.02      ,  UpperCamelCase=1e-12      ,  UpperCamelCase="first"      ,  UpperCamelCase=True      ,  UpperCamelCase="gelu"      ,  UpperCamelCase=0.1      ,  UpperCamelCase=0      ,  UpperCamelCase="absolute"      ,  UpperCamelCase=True      ,  UpperCamelCase=None      ,  **UpperCamelCase      ,  ):







   """simple docstring"""
   super().__init__(pad_token_id=UpperCamelCase      ,  **UpperCamelCase					)

   lowerCamelCase_								=  vocab_size
   lowerCamelCase_								=  embedding_size
   lowerCamelCase_								=  hidden_size
   lowerCamelCase_								=  num_hidden_layers
   lowerCamelCase_								=  num_attention_heads
   lowerCamelCase_								=  intermediate_size
   lowerCamelCase_								=  hidden_act
   lowerCamelCase_								=  hidden_dropout_prob
   lowerCamelCase_								=  attention_probs_dropout_prob
   lowerCamelCase_								=  max_position_embeddings
   lowerCamelCase_								=  type_vocab_size
   lowerCamelCase_								=  initializer_range
   lowerCamelCase_								=  layer_norm_eps

   lowerCamelCase_								=  summary_type
   lowerCamelCase_								=  summary_use_proj
   lowerCamelCase_								=  summary_activation
   lowerCamelCase_								=  summary_last_dropout
   lowerCamelCase_								=  position_embedding_type
   lowerCamelCase_								=  use_cache
   lowerCamelCase_								=  classifier_dropout





class 					snake_case   (   lowercase      ):





  """simple docstring"""




  @property
  def   snake_case		(   self					):







   """simple docstring"""
   if self.task == "multiple-choice":
    lowerCamelCase_								=  {0: "batch", 1: "choice", 2: "sequence"}
   else:
    lowerCamelCase_								=  {0: "batch", 1: "sequence"}
   return OrderedDict(
       [
           ("input_ids", dynamic_axis),
           ("attention_mask", dynamic_axis),
           ("token_type_ids", dynamic_axis),
       ]					)



